Merge branch 'fix/simplify_stock_reservations' of https://gitea.quo.ar/tbianchini/shopit-back into fix/simplify_stock_reservations

.env.example

@@ -5,6 +5,9 @@ APP_DEBUG=false
 APP_URL=http://localhost
 
 PURCHASE_CHECKOUT_EXPIRATION_MINUTES=30
+PURCHASE_QR_EXPIRATION_MINUTES=15
+PURCHASE_TELEPAGOS_EXPIRATION_MINUTES=30
+PURCHASE_TRANSFER_EXPIRATION_MINUTES=1440
 STOCK_RESERVATION_EXPIRATION_MINUTES=30
 FRONTEND_URLS=http://localhost:4200
 
@@ -28,7 +31,6 @@ AUTH_LOGIN_ATTEMPT_WINDOW_MINUTES=30
 AUTH_LOGIN_LOCK_MINUTES=15
 AUTH_LOGIN_RATE_LIMIT_PER_MINUTE=10
 AUTH_LOGIN_IP_RATE_LIMIT_PER_MINUTE=30
-AUTH_PASSWORD_RESET_EXPIRATION_MINUTES=60
 
 LOG_CHANNEL=daily
 LOG_STACK=single

app/Domains/Auth/Controllers/ValidateResetPasswordAttemptController.php

@@ -22,18 +22,10 @@ class ValidateResetPasswordAttemptController extends Controller
     {
         $data = $request->validated();
 
-        $result = $this->resetPasswordAttemptService->validateCode(
+        if (! $this->resetPasswordAttemptService->validateCode(
             $data['email'],
             $data['codigo'],
-        );
-
-        if ($result === ResetPasswordAttemptService::CODE_EXPIRED) {
-            throw ValidationException::withMessages([
-                'codigo' => __('api.auth.reset_code_expired'),
-            ]);
-        }
-
-        if ($result !== ResetPasswordAttemptService::CODE_VALID) {
+        )) {
             throw ValidationException::withMessages([
                 'codigo' => __('api.auth.reset_code_invalid'),
             ]);

app/Domains/Auth/Models/ResetPasswordAttempt.php

@@ -7,7 +7,7 @@ use Illuminate\Database\Eloquent\Attributes\Hidden;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
-#[Fillable(['user_id', 'codigo', 'reason', 'status', 'expires_at'])]
+#[Fillable(['user_id', 'codigo', 'reason', 'status'])]
 #[Hidden(['codigo'])]
 class ResetPasswordAttempt extends Model
 {
@@ -31,7 +31,6 @@ class ResetPasswordAttempt extends Model
     {
         return [
             'user_id' => 'integer',
-            'expires_at' => 'datetime',
         ];
     }
 

app/Domains/Auth/Services/ResetPasswordAttemptService.php

@@ -12,12 +12,6 @@ use Throwable;
 
 class ResetPasswordAttemptService
 {
-    public const CODE_VALID = 'valid';
-
-    public const CODE_INVALID = 'invalid';
-
-    public const CODE_EXPIRED = 'expired';
-
     public function createForEmail(
         string $email,
         string $tenantCode,
@@ -152,12 +146,12 @@ class ResetPasswordAttemptService
         );
     }
 
-    public function validateCode(string $email, string $code): string
+    public function validateCode(string $email, string $code): bool
     {
         $emailFingerprint = $this->emailFingerprint($email);
 
         try {
-            return DB::transaction(function () use ($email, $code, $emailFingerprint): string {
+            return DB::transaction(function () use ($email, $code, $emailFingerprint): bool {
                 $user = User::query()
                     ->where('email', $email)
                     ->lockForUpdate()
@@ -175,27 +169,14 @@ class ResetPasswordAttemptService
                         'email_fingerprint' => $emailFingerprint,
                     ]);
 
-                    return self::CODE_INVALID;
-                }
-
-                if ($attempt->expires_at?->isPast()) {
-                    $attempt->update([
-                        'status' => ResetPasswordAttempt::STATUS_EXPIRED,
-                    ]);
-
-                    Log::info('Password reset code validation failed: attempt expired.', [
-                        'email_fingerprint' => $emailFingerprint,
-                        'attempt_id' => $attempt->getKey(),
-                    ]);
-
-                    return self::CODE_EXPIRED;
+                    return false;
                 }
 
                 $attempt->update([
                     'status' => ResetPasswordAttempt::STATUS_VALIDATED,
                 ]);
 
-                return self::CODE_VALID;
+                return true;
             });
         } catch (Throwable $exception) {
             Log::error('Failed to validate password reset code.', [
@@ -233,19 +214,6 @@ class ResetPasswordAttemptService
                     return false;
                 }
 
-                if ($attempt->expires_at?->isPast()) {
-                    $attempt->update([
-                        'status' => ResetPasswordAttempt::STATUS_EXPIRED,
-                    ]);
-
-                    Log::info('Password reset failed: attempt expired.', [
-                        'email_fingerprint' => $emailFingerprint,
-                        'attempt_id' => $attempt->getKey(),
-                    ]);
-
-                    return false;
-                }
-
                 $user->password = $password;
                 $user->failed_login_attempts = 0;
                 $user->last_failed_login_at = null;
@@ -302,7 +270,6 @@ class ResetPasswordAttemptService
             'codigo' => $this->generateCode(),
             'reason' => $reason,
             'status' => ResetPasswordAttempt::STATUS_PENDING,
-            'expires_at' => now()->addMinutes((int) config('auth.passwords.users.expire')),
         ]);
 
         return $attempt->getKey();

app/Domains/Bootstrap/Resources/AdminAppBootstrapResource.php

@@ -30,7 +30,6 @@ class AdminAppBootstrapResource extends JsonResource
             'login_header_footer_color' => $websiteType->login_header_footer_color,
             'site_logo' => $websiteType->siteLogo?->getTemporaryUrl(1440),
             'footer_logo' => $websiteType->footerLogo?->getTemporaryUrl(1440),
-            'favicon' => $websiteType->favicon?->getTemporaryUrl(1440),
         ];
     }
 }

app/Domains/Bootstrap/Services/AdminAppBootstrapService.php

@@ -11,7 +11,7 @@ class AdminAppBootstrapService
     {
         return [
             'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo', 'favicon'])
+                ->with(['siteLogo', 'footerLogo'])
                 ->where('dominio', $domain)
                 ->firstOrFail(),
         ];

app/Domains/Bootstrap/Services/ScannerBootstrapService.php

@@ -11,7 +11,7 @@ class ScannerBootstrapService
     {
         return [
             'website_type' => WebsiteType::query()
-                ->with(['siteLogo', 'footerLogo', 'favicon'])
+                ->with(['siteLogo', 'footerLogo'])
                 ->where('scanner_domain', $domain)
                 ->firstOrFail(),
         ];

app/Domains/Catalog/Controllers/AdminApp/OnTicketFeaturedGroupController.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace App\Domains\Catalog\Controllers\AdminApp;
+
+use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Catalog\Requests\AdminApp\UpsertOnTicketFeaturedGroupRequest;
+use App\Domains\Catalog\Resources\AdminApp\OnTicketFeaturedGroupResource;
+use App\Domains\Catalog\Services\OnTicketFeaturedGroupService;
+use App\Domains\Tenant\Models\Tenant;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+
+class OnTicketFeaturedGroupController extends Controller
+{
+    public function __construct(
+        private readonly OnTicketFeaturedGroupService $featuredGroupService,
+    ) {}
+
+    public function index(Request $request): AnonymousResourceCollection
+    {
+        return OnTicketFeaturedGroupResource::collection(
+            $this->featuredGroupService->forTenant($this->onTicketTenant($request))
+        );
+    }
+
+    public function store(UpsertOnTicketFeaturedGroupRequest $request): JsonResponse
+    {
+        $featuredGroup = $this->featuredGroupService->create(
+            $this->onTicketTenant($request),
+            $request->validated(),
+        );
+
+        return OnTicketFeaturedGroupResource::make($featuredGroup)
+            ->response()
+            ->setStatusCode(201);
+    }
+
+    public function update(
+        UpsertOnTicketFeaturedGroupRequest $request,
+        FeaturedGroup $featuredGroup,
+    ): OnTicketFeaturedGroupResource {
+        $tenant = $this->onTicketTenant($request);
+
+        abort_unless($featuredGroup->tenant_code === $tenant->codigo, 404);
+
+        return OnTicketFeaturedGroupResource::make(
+            $this->featuredGroupService->update(
+                $tenant,
+                $featuredGroup,
+                $request->validated(),
+            )
+        );
+    }
+
+    private function onTicketTenant(Request $request): Tenant
+    {
+        $tenant = $request->user()->tenant()->firstOrFail();
+
+        abort_unless($tenant->website_type_code === 'onticket', 404);
+
+        return $tenant;
+    }
+}

app/Domains/Catalog/Requests/AdminApp/UpsertOnTicketFeaturedGroupRequest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Catalog\Requests\AdminApp;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpsertOnTicketFeaturedGroupRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'category_name' => ['required', 'string', 'max:255'],
+            'is_featured' => ['required', 'boolean'],
+        ];
+    }
+}

app/Domains/Catalog/Resources/AdminApp/OnTicketFeaturedGroupResource.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Domains\Catalog\Resources\AdminApp;
+
+use App\Domains\Catalog\Enums\ProductLayout;
+use App\Domains\Catalog\Models\FeaturedGroup;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin FeaturedGroup */
+class OnTicketFeaturedGroupResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'code' => $this->code,
+            'category_id' => $this->category_id,
+            'category_name' => $this->category->nombre,
+            'group_name' => $this->group_name,
+            'is_featured' => $this->product_layout === ProductLayout::Row,
+            'type' => $this->source_type->value,
+            'product_layout' => $this->product_layout->value,
+            'group_layout' => $this->group_layout->value,
+            'order' => $this->group_order,
+        ];
+    }
+}

app/Domains/Catalog/Services/OnTicketFeaturedGroupService.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace App\Domains\Catalog\Services;
+
+use App\Domains\Catalog\Enums\FeaturedGroupSource;
+use App\Domains\Catalog\Enums\GroupLayout;
+use App\Domains\Catalog\Enums\ProductLayout;
+use App\Domains\Catalog\Models\Category;
+use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\DB;
+
+class OnTicketFeaturedGroupService
+{
+    /** @return Collection<int, FeaturedGroup> */
+    public function forTenant(Tenant $tenant): Collection
+    {
+        return FeaturedGroup::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('source_type', FeaturedGroupSource::Category)
+            ->whereHas('category', fn ($query) => $query->where('tenant_code', $tenant->codigo))
+            ->with('category')
+            ->orderBy('group_order')
+            ->orderBy('id')
+            ->get();
+    }
+
+    /** @param array{category_name: string, is_featured: bool} $data */
+    public function create(Tenant $tenant, array $data): FeaturedGroup
+    {
+        return DB::transaction(function () use ($tenant, $data): FeaturedGroup {
+            $category = $tenant->categories()->create([
+                'nombre' => $data['category_name'],
+            ]);
+
+            $featuredGroup = FeaturedGroup::query()->create([
+                'tenant_code' => $tenant->codigo,
+                'source_type' => FeaturedGroupSource::Category,
+                'category_id' => $category->id,
+                'product_layout' => $this->productLayout($data['is_featured']),
+                'group_layout' => GroupLayout::Paginated,
+                'group_name' => $data['category_name'],
+                'group_order' => $this->nextOrder($tenant),
+            ]);
+
+            return $featuredGroup->setRelation('category', $category);
+        });
+    }
+
+    /** @param array{category_name: string, is_featured: bool} $data */
+    public function update(
+        Tenant $tenant,
+        FeaturedGroup $featuredGroup,
+        array $data,
+    ): FeaturedGroup {
+        return DB::transaction(function () use ($tenant, $featuredGroup, $data): FeaturedGroup {
+            $featuredGroup = FeaturedGroup::query()
+                ->whereKey($featuredGroup->getKey())
+                ->where('tenant_code', $tenant->codigo)
+                ->where('source_type', FeaturedGroupSource::Category)
+                ->lockForUpdate()
+                ->firstOrFail();
+
+            $category = Category::query()
+                ->whereKey($featuredGroup->category_id)
+                ->where('tenant_code', $tenant->codigo)
+                ->lockForUpdate()
+                ->firstOrFail();
+
+            $category->update(['nombre' => $data['category_name']]);
+            $featuredGroup->update([
+                'group_name' => $data['category_name'],
+                'product_layout' => $this->productLayout($data['is_featured']),
+                'group_layout' => GroupLayout::Paginated,
+            ]);
+
+            return $featuredGroup->setRelation('category', $category);
+        });
+    }
+
+    private function productLayout(bool $isFeatured): ProductLayout
+    {
+        return $isFeatured ? ProductLayout::Row : ProductLayout::ColumnWithCart;
+    }
+
+    private function nextOrder(Tenant $tenant): int
+    {
+        $maximumOrder = FeaturedGroup::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->max('group_order');
+
+        return $maximumOrder === null ? 0 : ((int) $maximumOrder) + 1;
+    }
+}

app/Domains/Catalog/Services/StockReservationService.php

@@ -343,9 +343,9 @@ class StockReservationService
         });
     }
 
-    public function clearExpirationForReview(Purchase $purchase): void
+    public function refreshForPurchase(Purchase $purchase, ?Carbon $expiresAt): void
     {
-        DB::transaction(function () use ($purchase): void {
+        DB::transaction(function () use ($purchase, $expiresAt): void {
             /** @var Purchase $purchase */
             $purchase = Purchase::query()->lockForUpdate()->findOrFail($purchase->getKey());
             if ($purchase->stock_reservation_id === null) {
@@ -363,7 +363,7 @@ class StockReservationService
                 throw new StockReservationExpiredException;
             }
 
-            $reservation->update(['expires_at' => null]);
+            $reservation->update(['expires_at' => $expiresAt]);
         });
     }
 

app/Domains/Catalog/documentacion/README.md

@@ -21,11 +21,16 @@ Modela y publica la oferta comercial del tenant: productos, variantes, categorí
 - `StockReservationService`: sincroniza el carrito como conjunto, bloquea todos sus inventarios en orden estable y mantiene el ledger agregado consistente con `Inventory.reserved_stock`.
 - `ExpireStockReservationsService`: detecta en un único recorrido reservas vencidas de compras, carritos y huérfanas, y delega los efectos comerciales sin mezclar esas reglas con la liberación física del inventario.
 - `FeaturedGroupService`: pagina los ítems destacados para la tienda.
+- `OnTicketFeaturedGroupService`: administra grupos destacados del panel para sitios de tickets.
 
 ## Endpoints de tienda
 
 Bajo `/tenants/{tenant:codigo}` se publican catálogo, búsqueda, categoría, detalle, alta de ítems y paginación de grupos destacados.
 
+## Endpoints administrativos
+
+Bajo `/v1/adminapp/tenant/featured-groups`, con `auth:sanctum` y `adminapp.tenant`, se listan, crean y actualizan grupos destacados.
+
 ## Dependencias y reglas
 
 Usa `Attachable` para imágenes/archivos, `Tenant` para aislamiento y `Ticket`/`Event` para vigencia y fechas. `Cart` y `Purchase` consumen sus precios, variantes e inventario. Los cambios de stock deben pasar por `CatalogInventoryService` para conservar reservas y disponibilidad.

app/Domains/Catalog/routes/adminapp.php

@@ -0,0 +1,15 @@
+<?php
+
+use App\Domains\Catalog\Controllers\AdminApp\OnTicketFeaturedGroupController;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('v1/adminapp/tenant')
+    ->middleware(['auth:sanctum', 'adminapp.tenant'])
+    ->group(function (): void {
+        Route::get('featured-groups', [OnTicketFeaturedGroupController::class, 'index'])
+            ->name('adminapp.featured-groups.index');
+        Route::post('featured-groups', [OnTicketFeaturedGroupController::class, 'store'])
+            ->name('adminapp.featured-groups.store');
+        Route::put('featured-groups/{featuredGroup}', [OnTicketFeaturedGroupController::class, 'update'])
+            ->name('adminapp.featured-groups.update');
+    });

app/Domains/Catalog/routes/api.php

@@ -15,3 +15,5 @@ Route::prefix('tenants/{tenant:codigo}')->group(function (): void {
     Route::post('catalog-items/{catalogItem}/variant-options', [CatalogController::class, 'variantOptions']);
     Route::post('catalog-items', [CatalogController::class, 'store']);
 });
+
+require __DIR__.'/adminapp.php';

app/Domains/Client/Controllers/ClientController.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Domains\Client\Controllers;
+
+use App\Domains\Client\Models\Client;
+use App\Domains\Client\Requests\StoreClientRequest;
+use App\Domains\Client\Requests\UpdateClientRequest;
+use App\Domains\Client\Resources\ClientResource;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Response;
+
+class ClientController extends Controller
+{
+    public function index(): JsonResponse
+    {
+        return ClientResource::collection(
+            Client::query()->with('tenants')->latest()->paginateFromRequest()
+        )->response();
+    }
+
+    public function store(StoreClientRequest $request): JsonResponse
+    {
+        return ClientResource::make(
+            Client::query()->create($request->validated())->load('tenants')
+        )->response()->setStatusCode(201);
+    }
+
+    public function show(Client $client): ClientResource
+    {
+        return ClientResource::make($client->load('tenants'));
+    }
+
+    public function update(UpdateClientRequest $request, Client $client): ClientResource
+    {
+        $client->update($request->validated());
+
+        return ClientResource::make($client->fresh()->load('tenants'));
+    }
+
+    public function destroy(Client $client): Response
+    {
+        $client->delete();
+
+        return response()->noContent();
+    }
+}

app/Domains/Client/Requests/StoreClientRequest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Client\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class StoreClientRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'code' => ['required', 'string', 'max:255', Rule::unique('clients', 'code')],
+            'name' => ['required', 'string', 'max:255'],
+        ];
+    }
+}

app/Domains/Client/Requests/UpdateClientRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Client\Requests;
+
+use App\Domains\Client\Models\Client;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class UpdateClientRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        /** @var Client|null $client */
+        $client = $this->route('client');
+
+        return [
+            'code' => ['sometimes', 'string', 'max:255', Rule::unique('clients', 'code')->ignore($client?->id)],
+            'name' => ['sometimes', 'string', 'max:255'],
+        ];
+    }
+}

app/Domains/Client/Resources/ClientResource.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Client\Resources;
+
+use App\Domains\Client\Models\Client;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin Client */
+class ClientResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'code' => $this->code,
+            'name' => $this->name,
+            'tenants' => $this->whenLoaded('tenants', fn () => $this->tenants->map(fn ($tenant): array => [
+                'id' => $tenant->id,
+                'codigo' => $tenant->codigo,
+                'nombre' => $tenant->nombre,
+                'dominio' => $tenant->dominio,
+            ])),
+        ];
+    }
+}

app/Domains/Client/routes/api.php

@@ -0,0 +1,6 @@
+<?php
+
+use App\Domains\Client\Controllers\ClientController;
+use Illuminate\Support\Facades\Route;
+
+Route::apiResource('clients', ClientController::class);

app/Domains/Desfile/Controllers/EntryController.php

@@ -10,6 +10,7 @@ use App\Domains\Desfile\Services\EntryService;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
+use Illuminate\Http\Response;
 
 class EntryController extends Controller
 {
@@ -47,4 +48,10 @@ class EntryController extends Controller
         ));
     }
 
+    public function destroyImage(Request $request): Response
+    {
+        $this->entryService->deleteImage($request->user()->tenant()->firstOrFail());
+
+        return response()->noContent();
+    }
 }

app/Domains/Desfile/Services/EntryService.php

@@ -166,6 +166,19 @@ class EntryService
         return $this->current($tenant);
     }
 
+    public function deleteImage(Tenant $tenant): void
+    {
+        $attachment = DB::transaction(function () use ($tenant): Attachment {
+            $entry = $this->entryQuery($tenant)->lockForUpdate()->firstOrFail();
+            $attachment = $entry->allAttachments()->lockForUpdate()->firstOrFail();
+            $entry->allAttachments()->detach($attachment->id);
+
+            return $attachment;
+        });
+
+        $this->deleteIfUnused($attachment);
+    }
+
     /** @return Collection<string, ItemAttribute> */
     private function itemAttributes(CatalogItem $entry): Collection
     {

app/Domains/Desfile/routes/api.php

@@ -14,4 +14,6 @@ Route::prefix('v1/adminapp/tenant/desfile')
             ->name('adminapp.desfile.entries.image.replace');
         Route::patch('entries/image', [EntryController::class, 'updateImage'])
             ->name('adminapp.desfile.entries.image.update');
+        Route::delete('entries/image', [EntryController::class, 'destroyImage'])
+            ->name('adminapp.desfile.entries.image.destroy');
     });

app/Domains/Integration/Controllers/IntegrationController.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Domains\Integration\Controllers;
+
+use App\Domains\Integration\Models\Integration;
+use App\Domains\Integration\Requests\StoreIntegrationRequest;
+use App\Domains\Integration\Requests\UpdateIntegrationRequest;
+use Illuminate\Routing\Controller;
+
+class IntegrationController extends Controller
+{
+    public function index()
+    {
+        return response()->json(Integration::all());
+    }
+
+    public function store(StoreIntegrationRequest $request)
+    {
+        $integration = Integration::create($request->validated());
+
+        return response()->json($integration, 201);
+    }
+
+    public function show(Integration $integration)
+    {
+        return response()->json($integration);
+    }
+
+    public function update(UpdateIntegrationRequest $request, Integration $integration)
+    {
+        $integration->update($request->validated());
+
+        return response()->json($integration->fresh());
+    }
+
+    public function destroy(Integration $integration)
+    {
+        $integration->delete();
+
+        return response()->noContent();
+    }
+}

app/Domains/Integration/Controllers/TelepagosWebhookController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Domains\Integration\Controllers;
+
+use App\Domains\Client\Models\Client;
+use App\Domains\Integration\Requests\TelepagosWebhookRequest;
+use App\Domains\Integration\Services\TelepagosWebhookService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+
+class TelepagosWebhookController extends Controller
+{
+    /**
+     * Handle the incoming Telepagos webhook.
+     */
+    public function handle(TelepagosWebhookRequest $request, Client $client, TelepagosWebhookService $service): JsonResponse
+    {
+        try {
+            $cashinId = $request->validated('id');
+
+            $service->handleWebhook($client, $cashinId);
+
+            return response()->json(['status' => 'success']);
+        } catch (\Exception $e) {
+            return response()->json([
+                'status' => 'error',
+                'code' => 'integration.webhook_failed',
+                'message' => __('api.integration.webhook_failed'),
+            ], 500);
+        }
+    }
+}

app/Domains/Integration/Requests/StoreIntegrationRequest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Domains\Integration\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreIntegrationRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'integration_code' => ['required', 'string', 'unique:integrations,integration_code'],
+            'name' => ['required', 'string', 'max:255'],
+            'url' => ['nullable', 'url', 'max:255'],
+            'integration_data_schema' => ['nullable', 'array'],
+            'requires_client_configuration' => ['sometimes', 'boolean'],
+        ];
+    }
+}

app/Domains/Integration/Requests/TelepagosWebhookRequest.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Domains\Integration\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class TelepagosWebhookRequest extends FormRequest
+{
+    /**
+     * Determine if the user is authorized to make this request.
+     */
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the validation rules that apply to the request.
+     *
+     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array|string>
+     */
+    public function rules(): array
+    {
+        return [
+            'id' => ['required', 'string'],
+        ];
+    }
+}

app/Domains/Integration/Requests/UpdateIntegrationRequest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Domains\Integration\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class UpdateIntegrationRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        $integration = $this->route('integration');
+
+        return [
+            'name' => ['sometimes', 'required', 'string', 'max:255'],
+            'url' => ['nullable', 'url', 'max:255'],
+            'integration_data_schema' => ['nullable', 'array'],
+            'requires_client_configuration' => ['sometimes', 'boolean'],
+            // the code shouldn't ideally be updatable, but if it is:
+            'integration_code' => ['sometimes', 'required', 'string', 'unique:integrations,integration_code,'.($integration->id ?? '')],
+        ];
+    }
+}

app/Domains/Integration/Services/TelepagosWebhookService.php

@@ -0,0 +1,212 @@
+<?php
+
+namespace App\Domains\Integration\Services;
+
+use App\Domains\Client\Models\Client;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Purchase\Models\TelepagosPayment;
+use App\Domains\Purchase\Models\TelepagosQr;
+use App\Domains\Purchase\Services\CheckoutService;
+use Exception;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class TelepagosWebhookService
+{
+    public function __construct(
+        private readonly CheckoutService $checkoutService,
+    ) {}
+
+    /**
+     * Handle the Telepagos webhook notification.
+     *
+     * @throws Exception
+     */
+    public function handleWebhook(Client $client, string $cashinId): void
+    {
+        Log::channel('telepagos')->info('Telepagos webhook received.', [
+            'client_code' => $client->code,
+            'cashin_id' => $cashinId,
+        ]);
+
+        $telepagosService = new TelepagosIntegrationService;
+        $telepagosService->forClient($client);
+
+        try {
+            $details = $telepagosService->getCashinDetails($cashinId);
+
+            $qrOrderId = $details['data']['qr_order_id'] ?? $details['qr_order_id'] ?? null;
+            $amount = $this->normalizeAmount($details['data']['amount'] ?? $details['amount'] ?? 0);
+            $operationId = $details['data']['operation_id'] ?? $details['operation_id'] ?? null;
+
+            $paymentData = [
+                'compra_id' => null,
+                'matched_purchase_ids' => null,
+                'cuit_buyer' => $details['data']['buyer']['cuit'] ?? $details['buyer']['cuit'] ?? null,
+                'cvu_buyer' => $details['data']['buyer']['cvu'] ?? $details['buyer']['cvu'] ?? null,
+                'amount' => $amount,
+                'concept' => $details['data']['concept'] ?? $details['concept'] ?? null,
+                'operation' => $details['data']['operation'] ?? $details['operation'] ?? null,
+                'operation_id' => $details['data']['operation_id'] ?? $details['operation_id'] ?? null,
+                'transaction_id' => $details['data']['transaction_id'] ?? $details['transaction_id'] ?? null,
+                'qr_order_id' => $qrOrderId,
+                'link_id' => $details['data']['link_id'] ?? $details['link_id'] ?? null,
+            ];
+
+            $transferenciaOperationIds = [1, 3, 11];
+            $qrOperationIds = [31, 37, 47];
+
+            $compra = null;
+
+            if (in_array((int) $operationId, $transferenciaOperationIds, true)) {
+                $cuit = $details['data']['buyer']['cuit'] ?? $details['buyer']['cuit'] ?? null;
+
+                if (! $cuit) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: CUIT not found for transfer.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                    ]);
+
+                    return;
+                }
+
+                $dni = substr($cuit, 2, -1);
+
+                $tenantCodes = $client->tenants()->pluck('codigo');
+                $purchases = Purchase::whereIn('tenant_codigo', $tenantCodes)
+                    ->where('transfer_payer_dni', $dni)
+                    ->whereIn('status', [
+                        Purchase::STATUS_CREATED,
+                        Purchase::STATUS_PENDING_PAYMENT,
+                        Purchase::STATUS_IN_REVIEW,
+                    ])
+                    ->where('payment_method', 'transfer')
+                    ->where('total', $amount)
+                    ->latest()
+                    ->get();
+
+                $paymentData['matched_purchase_ids'] = $purchases->pluck('id')->all();
+                $compra = $purchases->count() === 1 ? $purchases->first() : null;
+
+                if (! $compra) {
+                    if ($purchases->count() > 1) {
+                        TelepagosPayment::create($paymentData);
+                    }
+
+                    Log::channel('telepagos')->warning('Telepagos webhook: Expected exactly one matching purchase.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'amount' => $amount,
+                        'matches' => $purchases->count(),
+                    ]);
+
+                    return;
+                }
+            } elseif (in_array((int) $operationId, $qrOperationIds, true)) {
+                if (! $qrOrderId) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: qr_order_id not present in provider response.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                    ]);
+
+                    return;
+                }
+
+                $telepagosQr = TelepagosQr::where('qr_order_id', $qrOrderId)->first();
+
+                if (! $telepagosQr) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: QR not found in database.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'qr_order_id' => $qrOrderId,
+                    ]);
+
+                    return;
+                }
+
+                $compra = $telepagosQr->compra;
+
+                if (! $compra) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: Purchase not found for QR.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'qr_order_id' => $qrOrderId,
+                    ]);
+
+                    return;
+                }
+
+                if (! $client->tenants()->where('codigo', $compra->tenant_codigo)->exists()) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: Purchase does not belong to client.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'purchase_id' => $compra->id,
+                    ]);
+
+                    return;
+                }
+
+                if (! in_array($compra->status, [
+                    Purchase::STATUS_PENDING_PAYMENT,
+                ], true)) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: Purchase is not awaiting payment confirmation.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'purchase_id' => $compra->id,
+                        'purchase_status' => $compra->status,
+                    ]);
+
+                    return;
+                }
+
+                $totalAmount = $this->normalizeAmount($compra->getTotalAmount());
+
+                if ($amount !== $totalAmount) {
+                    Log::channel('telepagos')->warning('Telepagos webhook: Amount mismatch.', [
+                        'client_code' => $client->code,
+                        'cashin_id' => $cashinId,
+                        'purchase_id' => $compra->id,
+                        'cashin_amount' => $amount,
+                        'purchase_amount' => $totalAmount,
+                    ]);
+
+                    return;
+                }
+            } else {
+                Log::channel('telepagos')->warning('Telepagos webhook: Unknown operation_id.', [
+                    'client_code' => $client->code,
+                    'cashin_id' => $cashinId,
+                    'operation_id' => $operationId,
+                ]);
+
+                return;
+            }
+
+            $paymentData['compra_id'] = $compra->id;
+
+            DB::transaction(function () use ($compra, $paymentData) {
+                TelepagosPayment::create($paymentData);
+                $this->checkoutService->confirmPaidPurchase($compra);
+            });
+
+            Log::channel('telepagos')->info('Telepagos webhook processed successfully.', [
+                'client_code' => $client->code,
+                'cashin_id' => $cashinId,
+                'purchase_id' => $compra->id,
+                'transaction_id' => $paymentData['transaction_id'],
+            ]);
+        } catch (Exception $e) {
+            Log::channel('telepagos')->error('Telepagos webhook processing failed.', [
+                'client_code' => $client->code,
+                'cashin_id' => $cashinId,
+                'error' => $e->getMessage(),
+            ]);
+            throw $e;
+        }
+    }
+
+    protected function normalizeAmount(mixed $amount): string
+    {
+        return number_format((float) $amount, 2, '.', '');
+    }
+}

app/Domains/Integration/documentacion/README.md

@@ -16,15 +16,18 @@ Gestiona integraciones externas disponibles y su configuración por cliente. Un
 - `BaseIntegrationService`: resuelve el cliente desde el tenant operativo y carga exclusivamente la configuración del cliente.
 - `MailService`: envío de correo usando la integración configurada.
 - `TelepagosIntegrationService`: autenticación, caché de token, generación de QR y consulta de cobros.
+- `TelepagosWebhookService`: procesa notificaciones recibidas desde Telepagos.
 
 ## Endpoints
 
+- CRUD global bajo `/integrations`.
 - Consulta y configuración por cliente bajo `/clients/{client}/integrations`.
+- `POST /webhooks/telepagos/{client}` para notificaciones del proveedor.
 
 ## Logging de Telepagos
 
-Los eventos de autenticación, QR y consultas de cuenta se escriben en el canal diario `telepagos`, separado del log general. Los archivos se generan en `storage/logs/telepagos/telepagos-YYYY-MM-DD.log`; el nivel y la retención se configuran con `TELEPAGOS_LOG_LEVEL` y `TELEPAGOS_LOG_DAYS`. Tokens y credenciales se eliminan del contexto antes de registrar respuestas del proveedor.
+Los eventos de autenticación, QR, consultas de cuenta y procesamiento de webhooks se escriben en el canal diario `telepagos`, separado del log general. Los archivos se generan en `storage/logs/telepagos/telepagos-YYYY-MM-DD.log`; el nivel y la retención se configuran con `TELEPAGOS_LOG_LEVEL` y `TELEPAGOS_LOG_DAYS`. Tokens y credenciales se eliminan del contexto antes de registrar respuestas del proveedor.
 
 ## Dependencias y reglas
 
-Se integra con `Client`, `Tenant` y con el checkout de `Purchase`. `Notification` utiliza `MailService`. El tenant conserva el contexto operativo y de branding, pero nunca es dueño de credenciales. Las credenciales no se exponen en respuestas ni logs.
+Se integra con `Client`, `Tenant` y con el checkout de `Purchase`. `Notification` utiliza `MailService`. El tenant conserva el contexto operativo y de branding, pero nunca es dueño de credenciales. Las credenciales no se exponen en respuestas ni logs; los webhooks deben validar su contrato antes de alterar una compra.

app/Domains/Integration/routes/api.php

@@ -1,10 +1,22 @@
 <?php
 
 use App\Domains\Integration\Controllers\ClientIntegrationController;
+use App\Domains\Integration\Controllers\IntegrationController;
+use App\Domains\Integration\Controllers\TelepagosWebhookController;
 use Illuminate\Support\Facades\Route;
 
+Route::group(['prefix' => 'integrations'], function () {
+    Route::get('/', [IntegrationController::class, 'index']);
+    Route::post('/', [IntegrationController::class, 'store']);
+    Route::get('/{integration}', [IntegrationController::class, 'show']);
+    Route::put('/{integration}', [IntegrationController::class, 'update']);
+    Route::delete('/{integration}', [IntegrationController::class, 'destroy']);
+});
+
 Route::group(['prefix' => 'clients/{client}/integrations'], function () {
     Route::get('/', [ClientIntegrationController::class, 'index']);
     Route::get('/{integration_code}', [ClientIntegrationController::class, 'show']);
     Route::put('/{integration_code}', [ClientIntegrationController::class, 'store']);
 });
+
+Route::post('webhooks/telepagos/{client}', [TelepagosWebhookController::class, 'handle']);

app/Domains/MailTest/Controllers/MailTestController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Domains\MailTest\Controllers;
+
+use App\Domains\MailTest\Requests\SendTestMailRequest;
+use App\Domains\MailTest\Services\MailTestService;
+use App\Domains\Tenant\Models\Tenant;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+
+class MailTestController extends Controller
+{
+    public function __construct(
+        protected MailTestService $mailTestService,
+    ) {}
+
+    public function __invoke(SendTestMailRequest $request, string $tenantCode): JsonResponse
+    {
+        $tenant = Tenant::query()
+            ->where('codigo', $tenantCode)
+            ->firstOrFail();
+
+        return response()->json(
+            $this->mailTestService->send(
+                $tenant,
+                $request->validated('to'),
+                $request->validated('subject'),
+                $request->validated('message'),
+            )
+        );
+    }
+}

app/Domains/MailTest/Mailables/TestMail.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Domains\MailTest\Mailables;
+
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Mail\Mailables\Content;
+use Illuminate\Mail\Mailables\Envelope;
+use Illuminate\Queue\SerializesModels;
+
+class TestMail extends Mailable
+{
+    use Queueable, SerializesModels;
+
+    public function __construct(
+        public readonly string $mailSubject,
+        public readonly string $mailMessage,
+        public readonly Tenant $tenant,
+    ) {}
+
+    public function envelope(): Envelope
+    {
+        return new Envelope(subject: $this->mailSubject);
+    }
+
+    public function content(): Content
+    {
+        $this->tenant->loadMissing(['headerLogo', 'footerLogo']);
+
+        $branding = [
+            'name' => $this->tenant->nombre,
+            'primary_color' => $this->tenant->primary_color ?? '#6376f3',
+            'body_color' => '#334155',
+            'background_color' => '#f1f5f9',
+            'surface_color' => '#ffffff',
+            'header_bg_color' => $this->tenant->header_bg_color ?? '#ffffff',
+            'footer_bg_color' => $this->tenant->footer_bg_color ?? '#334155',
+        ];
+
+        return new Content(
+            view: 'mail.test',
+            with: [
+                'tenant' => $this->tenant,
+                'branding' => $branding,
+                'headerLogoUrl' => $this->tenant->headerLogo?->getTemporaryUrl(1440),
+                'footerLogoUrl' => $this->tenant->footerLogo?->getTemporaryUrl(1440),
+            ],
+        );
+    }
+}

app/Domains/MailTest/Requests/SendTestMailRequest.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Domains\MailTest\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class SendTestMailRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'to' => ['required', 'string', 'email', 'max:255'],
+            'subject' => ['nullable', 'string', 'max:255'],
+            'message' => ['nullable', 'string', 'max:5000'],
+        ];
+    }
+}

app/Domains/MailTest/Services/MailTestService.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Domains\MailTest\Services;
+
+use App\Domains\Integration\Services\MailService;
+use App\Domains\Tenant\Models\Tenant;
+
+class MailTestService
+{
+    /**
+     * @return array<string, string>
+     */
+    public function send(Tenant $tenant, string $recipient, ?string $subject = null, ?string $message = null): array
+    {
+        $subject ??= 'Prueba de correo de Shopit';
+        $message ??= 'Este es un correo de prueba enviado desde Shopit.';
+
+        $mailService = (new MailService)->forTenant($tenant->codigo);
+        $mailService->send(
+            $recipient,
+            $subject,
+            '<h1 style="margin: 0 0 20px;">'.e($subject).'</h1>'
+                .'<p>'.nl2br(e($message)).'</p>',
+        );
+
+        return [
+            'code' => 'mail.test_sent',
+            'message' => __('api.mail.test_sent'),
+            'recipient' => $recipient,
+            'tenant_code' => $tenant->codigo,
+            'mailer' => $mailService->mailerName(),
+            'sent_at' => now()->toIso8601String(),
+        ];
+    }
+}

app/Domains/MailTest/documentacion/README.md

@@ -0,0 +1,24 @@
+# Dominio MailTest
+
+## Propósito
+
+Ofrece una operación técnica para verificar la configuración de correo de un tenant sin ejecutar un flujo funcional real.
+
+## Componentes
+
+- `MailTestController`: endpoint invocable de envío.
+- `SendTestMailRequest`: valida destinatario y contenido requerido.
+- `MailTestService`: coordina el envío de prueba.
+- `TestMail`: mailable utilizado para construir el mensaje.
+
+## Endpoint
+
+- `POST /{tenant_code}/mail-test/send`.
+
+## Dependencias
+
+Usa la configuración de correo del dominio `Integration` y resuelve el tenant indicado.
+
+## Consideraciones
+
+Es una herramienta de diagnóstico. Debe restringirse o deshabilitarse en entornos donde no corresponda exponer envíos de prueba, y nunca debe registrar credenciales.

app/Domains/MailTest/routes/api.php

@@ -0,0 +1,6 @@
+<?php
+
+use App\Domains\MailTest\Controllers\MailTestController;
+use Illuminate\Support\Facades\Route;
+
+Route::post('{tenant_code}/mail-test/send', MailTestController::class);

app/Domains/Menu/Controllers/MenuController.php

@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Domains\Menu\Controllers;
+
+use App\Domains\Menu\Models\Menu;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+
+class MenuController extends Controller
+{
+    public function index(): JsonResponse
+    {
+        $menues = Menu::all();
+
+        return response()->json($menues);
+    }
+
+    public function store(Request $request): JsonResponse
+    {
+        $validated = $request->validate([
+            'code' => 'required|string|unique:menues,code',
+            'label' => 'required|string|max:255',
+            'parent_menu_code' => [
+                'nullable',
+                'string',
+                Rule::exists('menues', 'code'),
+                'different:code',
+            ],
+            'content_type' => [
+                'sometimes',
+                Rule::in([Menu::CONTENT_TYPE_STATIC, Menu::CONTENT_TYPE_DYNAMIC]),
+            ],
+            'static_content_schema' => 'required_if:content_type,static|nullable|array',
+            'route' => 'required|string',
+        ]);
+
+        $menu = Menu::create($validated);
+
+        return response()->json($menu, 201);
+    }
+
+    public function show(Menu $menu): JsonResponse
+    {
+        return response()->json($menu);
+    }
+
+    public function update(Request $request, Menu $menu): JsonResponse
+    {
+        $validated = $request->validate([
+            'code' => 'sometimes|required|string|unique:menues,code,'.$menu->id,
+            'label' => 'sometimes|required|string|max:255',
+            'parent_menu_code' => [
+                'nullable',
+                'string',
+                Rule::exists('menues', 'code'),
+                Rule::notIn([$menu->code]),
+            ],
+            'content_type' => [
+                'sometimes',
+                Rule::in([Menu::CONTENT_TYPE_STATIC, Menu::CONTENT_TYPE_DYNAMIC]),
+            ],
+            'static_content_schema' => 'required_if:content_type,static|nullable|array',
+            'route' => 'sometimes|required|string',
+        ]);
+
+        $menu->update($validated);
+
+        return response()->json($menu);
+    }
+
+    public function destroy(Menu $menu): JsonResponse
+    {
+        $menu->delete();
+
+        return response()->json(null, 204);
+    }
+}

app/Domains/Menu/Controllers/TenantMenuController.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Domains\Menu\Controllers;
+
+use App\Domains\Menu\Models\Menu;
+use App\Domains\Menu\Requests\StoreTenantMenuRequest;
+use App\Domains\Menu\Services\TenantMenuService;
+use App\Domains\Tenant\Models\Tenant;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+
+class TenantMenuController extends Controller
+{
+    public function __construct(private readonly TenantMenuService $tenantMenuService) {}
+
+    public function store(
+        StoreTenantMenuRequest $request,
+        string $tenantCode,
+        string $menuCode,
+    ): JsonResponse {
+        $tenant = Tenant::query()->where('codigo', $tenantCode)->firstOrFail();
+        $menu = Menu::query()->where('code', $menuCode)->firstOrFail();
+
+        $tenantMenu = $this->tenantMenuService->configure(
+            $tenant,
+            $menu,
+            $request->validated('static_content'),
+        );
+
+        return response()->json($tenantMenu);
+    }
+}

app/Domains/Menu/Requests/StoreTenantMenuRequest.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Domains\Menu\Requests;
+
+use App\Domains\Menu\Models\Menu;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\ValidationException;
+
+class StoreTenantMenuRequest extends FormRequest
+{
+    private ?Menu $menuModel = null;
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $this->menuModel = Menu::query()
+            ->where('code', $this->route('menu_code'))
+            ->first();
+
+        if (! $this->menuModel) {
+            throw ValidationException::withMessages([
+                'menu_code' => __('api.menu.not_found'),
+            ]);
+        }
+    }
+
+    public function rules(): array
+    {
+        if ($this->menuModel?->content_type !== Menu::CONTENT_TYPE_STATIC) {
+            return [
+                'static_content' => ['nullable', 'array'],
+            ];
+        }
+
+        $rules = [
+            'static_content' => ['required', 'array'],
+        ];
+
+        foreach ($this->menuModel->static_content_schema as $field => $rule) {
+            $rules["static_content.{$field}"] = $rule;
+        }
+
+        return $rules;
+    }
+}

app/Domains/Menu/Services/TenantMenuService.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\Menu\Services;
+
+use App\Domains\Menu\Models\Menu;
+use App\Domains\Menu\Models\TenantMenu;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Support\Facades\DB;
+
+class TenantMenuService
+{
+    public function configure(Tenant $tenant, Menu $menu, ?array $staticContent): TenantMenu
+    {
+        return DB::transaction(fn () => TenantMenu::query()->updateOrCreate(
+            [
+                'tenant_code' => $tenant->codigo,
+                'menu_code' => $menu->code,
+            ],
+            [
+                'static_content' => $menu->content_type === Menu::CONTENT_TYPE_STATIC
+                    ? $staticContent
+                    : null,
+            ],
+        ));
+    }
+}

app/Domains/Menu/documentacion/README.md

@@ -10,6 +10,15 @@ Define menús disponibles y permite configurar su contenido para cada tenant y r
 - `TenantMenu`: configuración específica por tenant, incluyendo contenido estático cuando corresponde.
 - `MenuRole`: asociación entre menú y rol autorizado.
 
+## Servicios
+
+`TenantMenuService::configure()` crea o actualiza atómicamente la configuración de un menú para un tenant. Solo conserva `static_content` cuando el menú fue definido como contenido estático.
+
+## Endpoints
+
+- Recurso REST `/menues` mediante `MenuController`.
+- `POST /{tenant_code}/menues/{menu_code}` para configurar un menú del tenant.
+
 ## Dependencias y reglas
 
-Depende de `Tenant` y `Authorization`. Los menús se configuran mediante seeders y relaciones internas; no se exponen endpoints públicos de administración.
+Depende de `Tenant` y `Authorization`. Los códigos de menú y tenant forman la identidad lógica de la configuración; el contenido enviado debe respetar el tipo definido por `Menu`.

app/Domains/Menu/routes/api.php

@@ -0,0 +1,12 @@
+<?php
+
+use App\Domains\Menu\Controllers\MenuController;
+use App\Domains\Menu\Controllers\TenantMenuController;
+use Illuminate\Support\Facades\Route;
+
+Route::apiResource('menues', MenuController::class);
+
+Route::post(
+    '{tenant_code}/menues/{menu_code}',
+    [TenantMenuController::class, 'store']
+);

app/Domains/Notification/Events/TicketsAvailable.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Domains\Notification\Events;
+
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class TicketsAvailable
+{
+    use Dispatchable, SerializesModels;
+
+    /**
+     * @param  array<int, int>  $ticketIds
+     */
+    public function __construct(
+        public readonly int $purchaseId,
+        public readonly array $ticketIds,
+    ) {}
+}

app/Domains/Notification/Listeners/SendPurchasePaidEmail.php

@@ -7,7 +7,7 @@ use App\Domains\Purchase\Events\PurchasePaid;
 use Illuminate\Contracts\Queue\ShouldQueueAfterCommit;
 use Illuminate\Queue\InteractsWithQueue;
 
-class SendPurchaseConfirmedEmail implements ShouldQueueAfterCommit
+class SendPurchasePaidEmail implements ShouldQueueAfterCommit
 {
     use InteractsWithQueue;
 
@@ -20,6 +20,6 @@ class SendPurchaseConfirmedEmail implements ShouldQueueAfterCommit
 
     public function handle(PurchasePaid $event): void
     {
-        app(NotificationMailService::class)->sendPurchaseConfirmed($event->purchaseId);
+        app(NotificationMailService::class)->sendPurchasePaid($event->purchaseId);
     }
 }

app/Domains/Notification/Listeners/SendTicketsAvailableEmail.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Domains\Notification\Listeners;
+
+use App\Domains\Notification\Events\TicketsAvailable;
+use App\Domains\Notification\Services\NotificationMailService;
+use Illuminate\Contracts\Queue\ShouldQueueAfterCommit;
+use Illuminate\Queue\InteractsWithQueue;
+
+class SendTicketsAvailableEmail implements ShouldQueueAfterCommit
+{
+    use InteractsWithQueue;
+
+    public string $queue = 'emails';
+
+    public int $tries = 3;
+
+    /** @var array<int, int> */
+    public array $backoff = [30, 120, 300];
+
+    public function handle(TicketsAvailable $event): void
+    {
+        app(NotificationMailService::class)->sendTicketsAvailable($event->purchaseId, $event->ticketIds);
+    }
+}

app/Domains/Notification/Services/NotificationMailService.php

@@ -119,17 +119,55 @@ class NotificationMailService
         });
     }
 
-    public function sendPurchaseConfirmed(int $purchaseId): void
+    public function sendPurchasePaid(int $purchaseId): void
     {
         $context = ['purchase_id' => $purchaseId];
 
-        $this->sendLogged('purchase_confirmed', $context, function () use ($purchaseId, $context): ?array {
+        $this->sendLogged('purchase_paid', $context, function () use ($purchaseId, $context): ?array {
             $purchase = Purchase::query()
                 ->with(['tenant', 'user', 'items'])
                 ->find($purchaseId);
 
             if ($purchase === null) {
-                $this->logSkipped('purchase_confirmed', array_merge($context, [
+                $this->logSkipped('purchase_paid', array_merge($context, [
+                    'reason' => 'purchase_not_found',
+                    'missing_model' => Purchase::class,
+                ]));
+
+                return null;
+            }
+
+            $this->mailService
+                ->forTenant($purchase->tenant_codigo)
+                ->send(
+                    $this->recipientFor($purchase),
+                    "Pago confirmado - Compra #{$purchase->getKey()}",
+                    view('mail.notifications.purchase-paid', compact('purchase'))->render(),
+                );
+
+            return [
+                'tenant_code' => $purchase->tenant_codigo,
+                'user_id' => $purchase->user_id,
+                'purchase_status' => $purchase->status,
+                'purchase_item_count' => $purchase->items->count(),
+            ];
+        });
+    }
+
+    /** @param array<int, int> $ticketIds */
+    public function sendTicketsAvailable(int $purchaseId, array $ticketIds): void
+    {
+        $context = [
+            'purchase_id' => $purchaseId,
+            'requested_ticket_count' => count($ticketIds),
+            'requested_ticket_ids' => $ticketIds,
+        ];
+
+        $this->sendLogged('tickets_available', $context, function () use ($purchaseId, $ticketIds, $context): ?array {
+            $purchase = Purchase::query()->with(['tenant', 'user'])->find($purchaseId);
+
+            if ($purchase === null) {
+                $this->logSkipped('tickets_available', array_merge($context, [
                     'reason' => 'purchase_not_found',
                     'missing_model' => Purchase::class,
                 ]));
@@ -139,34 +177,41 @@ class NotificationMailService
 
             /** @var Collection<int, Ticket> $tickets */
             $tickets = Ticket::query()
-                ->where('source_purchase_id', $purchase->getKey())
                 ->where('tenant_code', $purchase->tenant_codigo)
+                ->where('user_id', $purchase->user_id)
+                ->whereKey($ticketIds)
                 ->with(TicketPresentationResolver::RELATIONS)
                 ->get();
-            $attachments = $tickets->isEmpty()
-                ? []
-                : [[
-                    'data' => $this->ticketPdfService->contents($purchase->tenant, $tickets),
-                    'name' => $this->ticketPdfService->filename($tickets),
-                    'mime' => 'application/pdf',
-                ]];
+
+            if ($tickets->isEmpty()) {
+                $this->logSkipped('tickets_available', array_merge($context, [
+                    'reason' => 'tickets_not_found',
+                    'missing_model' => Ticket::class,
+                    'tenant_code' => $purchase->tenant_codigo,
+                    'user_id' => $purchase->user_id,
+                ]));
+
+                return null;
+            }
 
             $this->mailService
                 ->forTenant($purchase->tenant_codigo)
                 ->send(
                     $this->recipientFor($purchase),
-                    "Compra confirmada - Compra #{$purchase->getKey()}",
-                    view('mail.notifications.purchase-confirmed', compact('purchase', 'tickets'))->render(),
-                    attachments: $attachments,
+                    'Tus tickets ya están disponibles',
+                    view('mail.notifications.tickets-available', compact('purchase', 'tickets'))->render(),
+                    attachments: [[
+                        'data' => $this->ticketPdfService->contents($purchase->tenant, $tickets),
+                        'name' => $this->ticketPdfService->filename($tickets),
+                        'mime' => 'application/pdf',
+                    ]],
                 );
 
             return [
                 'tenant_code' => $purchase->tenant_codigo,
                 'user_id' => $purchase->user_id,
-                'purchase_status' => $purchase->status,
-                'purchase_item_count' => $purchase->items->count(),
-                'ticket_count' => $tickets->count(),
-                'ticket_ids' => $tickets->modelKeys(),
+                'sent_ticket_count' => $tickets->count(),
+                'sent_ticket_ids' => $tickets->modelKeys(),
             ];
         });
     }

app/Domains/Notification/documentacion/README.md

@@ -8,11 +8,12 @@ Orquesta notificaciones de negocio por correo a partir de eventos de otros domin
 
 - `UserRegistered`: dispara el correo de bienvenida.
 - `PasswordResetRequested`: envía el código de recuperación si el intento sigue pendiente.
-- `PurchasePaid`: envía la confirmación de compra y adjunta los tickets generados, cuando corresponde.
+- `PurchasePaid`: envía la confirmación de pago.
+- `TicketsAvailable`: informa y entrega la disponibilidad de tickets.
 
 ## Componentes
 
-Los listeners `SendWelcomeEmail`, `SendPasswordResetEmail` y `SendPurchaseConfirmedEmail` delegan en `NotificationMailService`. Este servicio carga el contexto necesario, renderiza las vistas y envía mediante `Integration/MailService`.
+Los listeners `SendWelcomeEmail`, `SendPasswordResetEmail`, `SendPurchasePaidEmail` y `SendTicketsAvailableEmail` delegan en `NotificationMailService`. Este servicio carga el contexto necesario, renderiza las vistas y envía mediante `Integration/MailService`.
 
 ## API y dependencias
 
@@ -23,5 +24,5 @@ No expone rutas HTTP. Consume datos de `Auth`, `Tenant`, `Purchase` y `Ticket`,
 - Los listeners reciben identificadores y vuelven a cargar los modelos, evitando transportar entidades obsoletas.
 - La recuperación no se envía si el intento dejó de estar pendiente.
 - Los correos de cuenta (bienvenida y recuperación de contraseña) usan la identidad visual del `WebsiteType` asociado al tenant, con fallback al tenant si no tiene uno configurado.
-- El correo transaccional de compra confirmada usa la identidad visual del tenant y adjunta un único PDF cuando la compra generó tickets.
+- Los correos transaccionales (pago confirmado y tickets disponibles) usan la identidad visual del tenant/evento de la compra.
 - Los handlers deben permanecer idempotentes o tolerantes a reintentos de cola.

app/Domains/Purchase/Controllers/PurchaseController.php

@@ -93,6 +93,7 @@ class PurchaseController extends Controller
         PaymentIntentRequest $request,
         Tenant $tenant,
         Purchase $compra,
+        CheckoutService $checkoutService,
         PurchaseStateGuard $purchaseState,
     ): JsonResponse {
         $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
@@ -102,6 +103,7 @@ class PurchaseController extends Controller
             : null;
 
         $updated = DB::transaction(function () use (
+            $checkoutService,
             $compra,
             $method,
             $purchaseState,
@@ -140,6 +142,12 @@ class PurchaseController extends Controller
                 $purchaseUpdate['transfer_payer_dni'] = $transferPayerDni;
             }
             $purchase->update($purchaseUpdate);
+            $checkoutService->refreshReservationExpiration(
+                $purchase,
+                now()->addMinutes(
+                    max(1, (int) config("purchase.payment_expiration_minutes.{$method}", 30)),
+                ),
+            );
 
             return true;
         });
@@ -243,6 +251,15 @@ class PurchaseController extends Controller
         ], 400);
     }
 
+    public function complete(Request $request, Tenant $tenant, Purchase $compra, CheckoutService $checkoutService): PurchaseResource
+    {
+        $compra = $this->resolveScopedPurchase($tenant, $request->user()->id, $compra);
+
+        return PurchaseResource::make(
+            $checkoutService->completePurchase($compra)
+        );
+    }
+
     public function submitForReview(
         Request $request,
         Tenant $tenant,

app/Domains/Purchase/Resources/PurchaseResource.php

@@ -17,8 +17,6 @@ class PurchaseResource extends JsonResource
      */
     public function toArray(Request $request): array
     {
-        $serverTime = now();
-        $expiresAt = $this->stockReservation?->expires_at;
         $items = $this->resource->relationLoaded('items')
             ? $this->resource->getRelation('items')
             : collect();
@@ -50,11 +48,7 @@ class PurchaseResource extends JsonResource
             'created_at' => $this->created_at,
             'status' => $this->status,
             'payment_method' => $this->payment_method,
-            'expires_at' => $expiresAt,
-            'expires_in_seconds' => $expiresAt === null
-                ? null
-                : max(0, $expiresAt->getTimestamp() - $serverTime->getTimestamp()),
-            'server_time' => $serverTime,
+            'expires_at' => $this->stockReservation?->expires_at,
             'dni' => $this->dni,
             'transfer_payer_dni' => $this->transfer_payer_dni,
             'telefono' => $this->telefono,

app/Domains/Purchase/Services/Checkout/CompleteCheckoutService.php

@@ -18,6 +18,33 @@ class CompleteCheckoutService
         private readonly PurchaseStateGuard $purchaseState,
     ) {}
 
+    public function complete(Purchase $purchase): Purchase
+    {
+        return DB::transaction(function () use ($purchase): Purchase {
+            $purchase = $this->lockPurchase($purchase);
+            $this->purchaseState->assertNotExpired($purchase);
+
+            if ($purchase->payment_method === null) {
+                throw ValidationException::withMessages([
+                    'payment_method' => __('api.purchase.payment_method_required'),
+                ]);
+            }
+
+            if ($this->isTerminal($purchase)) {
+                return $this->loadPurchase($purchase);
+            }
+
+            $this->purchaseState->lockCurrentCart($purchase);
+
+            $purchase->update([
+                'status' => Purchase::STATUS_PENDING_PAYMENT,
+                'total' => $purchase->calculateCurrentTotalAmount(),
+            ]);
+
+            return $this->loadPurchase($purchase);
+        });
+    }
+
     public function submitForReview(Purchase $purchase): Purchase
     {
         return DB::transaction(function () use ($purchase): Purchase {
@@ -43,7 +70,7 @@ class CompleteCheckoutService
             $purchase->update([
                 'status' => Purchase::STATUS_IN_REVIEW,
             ]);
-            $this->reservations->clearExpirationForReview($purchase);
+            $this->reservations->refreshForPurchase($purchase, null);
 
             return $this->loadPurchase($purchase);
         });
@@ -144,6 +171,18 @@ class CompleteCheckoutService
         });
     }
 
+    private function isTerminal(Purchase $purchase): bool
+    {
+        return in_array($purchase->status, [
+            Purchase::STATUS_PAID,
+            Purchase::STATUS_IN_REVIEW,
+            Purchase::STATUS_CANCELLED,
+            Purchase::STATUS_REJECTED,
+            Purchase::STATUS_EXPIRED,
+            Purchase::STATUS_SUPERSEDED,
+        ], true);
+    }
+
     private function lockPurchase(Purchase $purchase): Purchase
     {
         /** @var Purchase */

app/Domains/Purchase/Services/CheckoutService.php

@@ -2,12 +2,14 @@
 
 namespace App\Domains\Purchase\Services;
 
+use App\Domains\Catalog\Services\StockReservationService;
 use App\Domains\Purchase\Models\Purchase;
 use App\Domains\Purchase\Services\Checkout\CompleteCheckoutService;
 use App\Domains\Purchase\Services\Checkout\EditCheckoutService;
 use App\Domains\Purchase\Services\Checkout\ReleaseCheckoutService;
 use App\Domains\Purchase\Services\Checkout\StartCheckoutService;
 use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\DB;
 
 /**
@@ -22,6 +24,7 @@ class CheckoutService
         private readonly EditCheckoutService $editor,
         private readonly CompleteCheckoutService $completer,
         private readonly ReleaseCheckoutService $releaser,
+        private readonly StockReservationService $reservations,
     ) {}
 
     /** @param array<string, mixed> $purchaseData */
@@ -30,6 +33,11 @@ class CheckoutService
         return $this->starter->start($tenant, $userId, $purchaseData);
     }
 
+    public function completePurchase(Purchase $purchase): Purchase
+    {
+        return $this->completer->complete($purchase);
+    }
+
     public function submitForReview(Purchase $purchase): Purchase
     {
         return $this->completer->submitForReview($purchase);
@@ -70,4 +78,9 @@ class CheckoutService
     {
         return $this->releaser->expire($purchase);
     }
+
+    public function refreshReservationExpiration(Purchase $purchase, ?Carbon $expiresAt): void
+    {
+        $this->reservations->refreshForPurchase($purchase, $expiresAt);
+    }
 }

app/Domains/Purchase/routes/api.php

@@ -9,6 +9,7 @@ Route::prefix('tenants/{tenant:codigo}')->middleware('auth:sanctum')->group(func
     Route::get('compras/{compra}', [PurchaseController::class, 'show']);
     Route::patch('compras/{compra}/customer-data', [PurchaseController::class, 'updateCustomerData']);
     Route::post('compras/{compra}/payment-intent', [PurchaseController::class, 'paymentIntent']);
+    Route::post('compras/{compra}/complete', [PurchaseController::class, 'complete']);
     Route::post('compras/{compra}/review', [PurchaseController::class, 'submitForReview']);
     Route::post('compras/{compra}/cancel', [PurchaseController::class, 'cancel']);
 });

app/Domains/Staff/routes/api.php

@@ -6,8 +6,5 @@ use Illuminate\Support\Facades\Route;
 Route::prefix('v1/adminapp/tenant')
     ->middleware(['auth:sanctum', 'adminapp.tenant'])
     ->group(function (): void {
-        Route::get('staff', [AdminAppStaffController::class, 'index']);
-        Route::post('staff', [AdminAppStaffController::class, 'store']);
-        Route::put('staff/{staff}', [AdminAppStaffController::class, 'update']);
-        Route::delete('staff/{staff}', [AdminAppStaffController::class, 'destroy']);
+        Route::apiResource('staff', AdminAppStaffController::class)->except('show');
     });

app/Domains/StorageTest/Controllers/S3TestController.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Domains\StorageTest\Controllers;
+
+use App\Domains\Attachable\Services\AttachmentService;
+use App\Domains\StorageTest\Requests\GenerateS3TemporaryUrlRequest;
+use App\Domains\StorageTest\Requests\StoreS3TestFileRequest;
+use App\Domains\StorageTest\Services\S3TestService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+
+class S3TestController extends Controller
+{
+    public function __construct(
+        protected AttachmentService $attachmentService,
+        protected S3TestService $s3TestService,
+    ) {
+    }
+
+    public function store(StoreS3TestFileRequest $request): JsonResponse
+    {
+        $attachment = $this->attachmentService->store(
+            $request->file('file') ?? (string) $request->validated('file_base64'),
+            $request->validated('path'),
+        );
+
+        $temporaryUrl = $this->s3TestService->generateTemporaryUrl(
+            $attachment->path,
+            (int) $request->validated('expires_in_minutes', 10),
+        );
+
+        return response()->json(
+            [
+                'id' => $attachment->id,
+                'key' => $attachment->key,
+                'path' => $attachment->path,
+                'filename' => $attachment->filename,
+                'type' => $attachment->type->value,
+                'mime_type' => $attachment->mime_type,
+                'extension' => $attachment->extension,
+                'size' => $attachment->size,
+                'temporary_url' => $temporaryUrl['temporary_url'],
+                'temporary_url_expires_at' => $temporaryUrl['temporary_url_expires_at'],
+            ],
+            201,
+        );
+    }
+
+    public function temporaryUrl(GenerateS3TemporaryUrlRequest $request): JsonResponse
+    {
+        return response()->json(
+            $this->s3TestService->generateTemporaryUrl(
+                $request->validated('path'),
+                (int) $request->validated('expires_in_minutes', 10),
+            )
+        );
+    }
+}

app/Domains/StorageTest/Requests/GenerateS3TemporaryUrlRequest.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Domains\StorageTest\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class GenerateS3TemporaryUrlRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'path' => ['required', 'string', 'max:2048'],
+            'expires_in_minutes' => ['nullable', 'integer', 'min:1', 'max:1440'],
+        ];
+    }
+}

app/Domains/StorageTest/Requests/StoreS3TestFileRequest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Domains\StorageTest\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreS3TestFileRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public function rules(): array
+    {
+        return [
+            'file' => ['nullable', 'file', 'max:10240', 'required_without:file_base64'],
+            'file_base64' => ['nullable', 'string', 'required_without:file'],
+            'path' => ['required', 'string', 'max:2048'],
+            'expires_in_minutes' => ['nullable', 'integer', 'min:1', 'max:1440'],
+        ];
+    }
+}

app/Domains/StorageTest/Services/S3TestService.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Domains\StorageTest\Services;
+
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+class S3TestService
+{
+    /**
+     * @return array<string, int|string|null>
+     */
+    public function storeTestFile(
+        UploadedFile $file,
+        ?string $directory = null,
+        int $expiresInMinutes = 10,
+    ): array {
+        $directory = $this->normalizeDirectory($directory);
+        $disk = Storage::disk('s3');
+        $path = $disk->putFile($directory, $file);
+
+        if (! is_string($path) || $path === '') {
+            Log::error('S3 upload returned an empty path.', [
+                'disk' => 's3',
+                'directory' => $directory,
+                'original_name' => $file->getClientOriginalName(),
+                'mime_type' => $file->getClientMimeType(),
+                'size' => $file->getSize(),
+            ]);
+
+            throw new RuntimeException('No se pudo subir el archivo al disco s3.');
+        }
+
+        return [
+            'disk' => 's3',
+            'directory' => $directory,
+            'key' => $path,
+            'path' => $path,
+            'filename' => basename($path),
+            'original_name' => $file->getClientOriginalName(),
+            'mime_type' => $file->getClientMimeType(),
+            'extension' => $file->extension(),
+            'size' => $file->getSize(),
+            'temporary_url' => $disk->temporaryUrl($path, now()->addMinutes($expiresInMinutes)),
+            'temporary_url_expires_at' => now()->addMinutes($expiresInMinutes)->toIso8601String(),
+        ];
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function generateTemporaryUrl(string $path, int $expiresInMinutes = 10): array
+    {
+        return [
+            'disk' => 's3',
+            'key' => $path,
+            'path' => $path,
+            'temporary_url' => $this->temporaryUrlForPath($path, $expiresInMinutes),
+            'temporary_url_expires_at' => now()->addMinutes($expiresInMinutes)->toIso8601String(),
+        ];
+    }
+
+    protected function temporaryUrlForPath(string $path, int $expiresInMinutes): string
+    {
+        return Storage::disk('s3')->temporaryUrl($path, now()->addMinutes($expiresInMinutes));
+    }
+
+    protected function normalizeDirectory(?string $directory): string
+    {
+        $directory = trim((string) $directory, '/');
+
+        if ($directory !== '') {
+            return $directory;
+        }
+
+        return 'testing/attachments/'.now()->format('Y/m/d').'/'.Str::uuid();
+    }
+}

app/Domains/StorageTest/documentacion/README.md

@@ -0,0 +1,23 @@
+# Dominio StorageTest
+
+## Propósito
+
+Expone operaciones técnicas para comprobar la escritura en S3 y la generación de URL temporales.
+
+## Componentes
+
+- `S3TestController`: recibe solicitudes de carga y URL temporal.
+- `S3TestService`: almacena un archivo de prueba y genera el enlace firmado.
+- `StoreS3TestFileRequest`: valida la carga.
+- `GenerateS3TemporaryUrlRequest`: valida ruta y tiempo de expiración.
+
+## Endpoints
+
+Bajo `/storage-test/s3`:
+
+- `POST /upload`.
+- `GET /temporary-url`.
+
+## Consideraciones
+
+Es infraestructura de diagnóstico, no una API funcional de archivos. Debe restringirse por entorno o autorización. Para adjuntos de negocio se debe usar el dominio `Attachable`.

app/Domains/StorageTest/routes/api.php

@@ -0,0 +1,9 @@
+<?php
+
+use App\Domains\StorageTest\Controllers\S3TestController;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('storage-test/s3')->group(function (): void {
+    Route::post('upload', [S3TestController::class, 'store']);
+    Route::get('temporary-url', [S3TestController::class, 'temporaryUrl']);
+});

app/Domains/Tenant/Controllers/AdminApp/WebsiteExtraController.php

@@ -5,6 +5,7 @@ namespace App\Domains\Tenant\Controllers\AdminApp;
 use App\Domains\Auth\Models\User;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Tenant\Requests\AdminApp\UpdateWebsiteExtraRequest;
+use App\Domains\Tenant\Resources\AdminApp\WebsiteExtraResource;
 use App\Domains\Tenant\Resources\AdminApp\WebsiteExtrasResource;
 use App\Domains\Tenant\Services\TenantInformationService;
 use App\Domains\Tenant\Services\WebsiteExtraService;
@@ -25,6 +26,20 @@ class WebsiteExtraController extends Controller
         );
     }
 
+    public function showExtra(Request $request, string $websiteExtraCode): WebsiteExtraResource
+    {
+        $tenant = $this->loadTenant($request->user());
+        $definition = $this->websiteExtraService->definitionForTenant($tenant, $websiteExtraCode);
+        $websiteExtra = $tenant->websiteExtras
+            ->firstWhere('website_type_extra_id', $definition->id);
+
+        if (! $websiteExtra) {
+            abort(404);
+        }
+
+        return WebsiteExtraResource::make($websiteExtra);
+    }
+
     public function update(
         UpdateWebsiteExtraRequest $request,
         string $websiteExtraCode

app/Domains/Tenant/Controllers/TenantController.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Domains\Tenant\Controllers;
+
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Tenant\Requests\StoreTenantRequest;
+use App\Domains\Tenant\Requests\UpdateTenantRequest;
+use App\Domains\Tenant\Resources\TenantResource;
+use App\Domains\Tenant\Services\TenantInformationService;
+use App\Domains\Tenant\Services\TenantService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Response;
+
+class TenantController extends Controller
+{
+    public function __construct(
+        protected TenantService $tenantService,
+        protected TenantInformationService $tenantInformationService,
+    ) {}
+
+    public function index(): JsonResponse
+    {
+        $tenants = Tenant::query()
+            ->latest()
+            ->paginateFromRequest();
+
+        $this->tenantInformationService->loadMany($tenants->getCollection());
+
+        return TenantResource::collection($tenants)->response();
+    }
+
+    public function store(StoreTenantRequest $request): JsonResponse
+    {
+        $tenant = $this->tenantService->create($request->validated());
+
+        return TenantResource::make(
+            $this->tenantInformationService->load($tenant)
+        )->response()->setStatusCode(201);
+    }
+
+    public function show(Tenant $tenant): TenantResource
+    {
+        return TenantResource::make(
+            $this->tenantInformationService->load($tenant)
+        );
+    }
+
+    public function update(UpdateTenantRequest $request, Tenant $tenant): TenantResource
+    {
+        $tenant = $this->tenantService->update($tenant, $request->validated());
+
+        return TenantResource::make(
+            $this->tenantInformationService->load($tenant)
+        );
+    }
+
+    public function destroy(Tenant $tenant): Response
+    {
+        $tenant->delete();
+
+        return response()->noContent();
+    }
+}

app/Domains/Tenant/Requests/StoreTenantRequest.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace App\Domains\Tenant\Requests;
+
+use App\Domains\Catalog\Enums\GroupLayout;
+use App\Domains\Catalog\Enums\ProductLayout;
+use App\Domains\Shared\Rules\ImageOrBase64Rule;
+use App\Domains\Tenant\Enums\CartEditingPolicy;
+use App\Domains\Tenant\Services\WebsiteExtraService;
+use App\Domains\Tenant\Support\TenantDomainNormalizer;
+use Closure;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class StoreTenantRequest extends FormRequest
+{
+    protected bool $hasInvalidDomain = false;
+
+    protected bool $hasInvalidBasePath = false;
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $rawDomain = $this->input('dominio');
+        $hasExplicitBasePath = $this->has('base_path');
+        $rawBasePath = $hasExplicitBasePath
+            ? $this->input('base_path')
+            : TenantDomainNormalizer::pathFromDomain($rawDomain);
+        $normalizedDomain = TenantDomainNormalizer::normalize($rawDomain);
+        $normalizedBasePath = TenantDomainNormalizer::normalizePath($rawBasePath);
+
+        $this->hasInvalidDomain = TenantDomainNormalizer::hasValue($rawDomain)
+            && $normalizedDomain === null;
+        $this->hasInvalidBasePath = ($hasExplicitBasePath && ! is_string($rawBasePath))
+            || $normalizedBasePath === null;
+
+        $this->merge([
+            'dominio' => $normalizedDomain,
+            'base_path' => $normalizedBasePath,
+        ]);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        $logoRule = ['required', new ImageOrBase64Rule];
+
+        return array_merge([
+            'client_id' => ['sometimes', 'integer', Rule::exists('clients', 'id')],
+            'codigo' => ['required', 'string', 'max:255', Rule::unique('tenants', 'codigo')],
+            'nombre' => ['required', 'string', 'max:255'],
+            'dominio' => [
+                'bail',
+                function (string $attribute, mixed $value, Closure $fail): void {
+                    if ($this->hasInvalidDomain) {
+                        $fail("The {$attribute} field must contain a valid domain or URL.");
+                    }
+                },
+                'required',
+                'string',
+                'max:255',
+                Rule::unique('tenants', 'dominio')
+                    ->where('base_path', $this->input('base_path')),
+            ],
+            'base_path' => [
+                'bail',
+                function (string $attribute, mixed $value, Closure $fail): void {
+                    if ($this->hasInvalidBasePath) {
+                        $fail("The {$attribute} field must contain a valid URL path.");
+                    }
+                },
+                'required',
+                'string',
+                'max:255',
+                Rule::unique('tenants', 'base_path')
+                    ->where('dominio', $this->input('dominio')),
+            ],
+            'site_title' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'address' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'phone' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'primary_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'secondary_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'danger_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'success_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'header_bg_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'footer_bg_color' => ['required', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'header_logo' => $logoRule,
+            'footer_logo' => $logoRule,
+            'favicon' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'header_bg_image' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'footer_bg_image' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'social_media' => ['sometimes', 'array'],
+            'social_media.*.code' => [
+                'required',
+                'string',
+                'distinct',
+                Rule::exists('social_media', 'code'),
+            ],
+            'social_media.*.url' => ['required', 'url', 'max:2048'],
+            'social_media.*.orden' => ['sometimes', 'integer', 'min:0', 'distinct'],
+            'search_product_layout' => ['sometimes', Rule::enum(ProductLayout::class)],
+            'search_group_layout' => ['sometimes', Rule::enum(GroupLayout::class)],
+            'search_items_per_page' => ['sometimes', 'integer', 'min:4', 'max:48'],
+            'display_categories' => ['sometimes', 'boolean'],
+            'display_seach_bar' => ['sometimes', 'boolean'],
+            'display_cart' => ['sometimes', 'boolean'],
+            'cart_editing_policy' => ['sometimes', Rule::enum(CartEditingPolicy::class)],
+            'checkout_editing_policy' => [
+                'sometimes',
+                Rule::in([CartEditingPolicy::Disabled->value]),
+            ],
+            'display_cart_item_images' => ['sometimes', 'boolean'],
+            'scanner_category_validation_enabled' => ['sometimes', 'boolean'],
+            'website_type_code' => [
+                'required_with:extras',
+                'sometimes',
+                'string',
+                Rule::exists('website_type', 'codigo'),
+            ],
+        ], app(WebsiteExtraService::class)->requestRules($this->input('website_type_code')));
+    }
+}

app/Domains/Tenant/Requests/UpdateTenantRequest.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace App\Domains\Tenant\Requests;
+
+use App\Domains\Catalog\Enums\GroupLayout;
+use App\Domains\Catalog\Enums\ProductLayout;
+use App\Domains\Shared\Rules\ImageOrBase64Rule;
+use App\Domains\Tenant\Enums\CartEditingPolicy;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Tenant\Support\TenantDomainNormalizer;
+use Closure;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class UpdateTenantRequest extends FormRequest
+{
+    protected bool $hasInvalidDomain = false;
+
+    protected bool $hasInvalidBasePath = false;
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if ($this->has('dominio')) {
+            $rawDomain = $this->input('dominio');
+            $normalizedDomain = TenantDomainNormalizer::normalize($rawDomain);
+            $embeddedBasePath = TenantDomainNormalizer::pathFromDomain($rawDomain);
+
+            $this->hasInvalidDomain = TenantDomainNormalizer::hasValue($rawDomain)
+                && ($normalizedDomain === null || $embeddedBasePath === null);
+
+            $this->merge([
+                'dominio' => $normalizedDomain,
+            ]);
+
+            if (! $this->has('base_path') && $embeddedBasePath !== null && $embeddedBasePath !== '/') {
+                $this->merge(['base_path' => $embeddedBasePath]);
+            }
+        }
+
+        if ($this->has('base_path')) {
+            $rawBasePath = $this->input('base_path');
+            $normalizedBasePath = TenantDomainNormalizer::normalizePath($rawBasePath);
+
+            $this->hasInvalidBasePath = ! is_string($rawBasePath)
+                || $normalizedBasePath === null;
+
+            $this->merge(['base_path' => $normalizedBasePath]);
+        }
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function rules(): array
+    {
+        /** @var Tenant|null $tenant */
+        $tenant = $this->route('tenant');
+        $domain = $this->input('dominio', $tenant?->dominio);
+        $basePath = $this->input('base_path', $tenant?->base_path ?? '/');
+
+        $logoRule = ['nullable', new ImageOrBase64Rule];
+
+        return [
+            'client_id' => ['sometimes', 'integer', Rule::exists('clients', 'id')],
+            'codigo' => [
+                'nullable',
+                'string',
+                'max:255',
+                Rule::unique('tenants', 'codigo')->ignore($tenant?->id),
+            ],
+            'nombre' => ['nullable', 'string', 'max:255'],
+            'dominio' => [
+                'bail',
+                function (string $attribute, mixed $value, Closure $fail): void {
+                    if ($this->hasInvalidDomain) {
+                        $fail("The {$attribute} field must contain a valid domain or URL.");
+                    }
+                },
+                'nullable',
+                'string',
+                'max:255',
+                Rule::unique('tenants', 'dominio')
+                    ->where('base_path', $basePath)
+                    ->ignore($tenant?->id),
+            ],
+            'base_path' => [
+                'bail',
+                function (string $attribute, mixed $value, Closure $fail): void {
+                    if ($this->hasInvalidBasePath) {
+                        $fail("The {$attribute} field must contain a valid URL path.");
+                    }
+                },
+                'nullable',
+                'string',
+                'max:255',
+                Rule::unique('tenants', 'base_path')
+                    ->where('dominio', $domain)
+                    ->ignore($tenant?->id),
+            ],
+            'site_title' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'address' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'phone' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'primary_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'secondary_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'danger_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'success_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'header_bg_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'footer_bg_color' => ['nullable', 'string', 'regex:/^#([a-fA-F0-9]{3,4}|[a-fA-F0-9]{6}|[a-fA-F0-9]{8})$/'],
+            'header_logo' => $logoRule,
+            'footer_logo' => $logoRule,
+            'favicon' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'header_bg_image' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'footer_bg_image' => ['sometimes', 'nullable', new ImageOrBase64Rule],
+            'social_media' => ['sometimes', 'array'],
+            'social_media.*.code' => [
+                'required',
+                'string',
+                'distinct',
+                Rule::exists('social_media', 'code'),
+            ],
+            'social_media.*.url' => ['required', 'url', 'max:2048'],
+            'social_media.*.orden' => ['sometimes', 'integer', 'min:0', 'distinct'],
+            'search_product_layout' => ['sometimes', Rule::enum(ProductLayout::class)],
+            'search_group_layout' => ['sometimes', Rule::enum(GroupLayout::class)],
+            'search_items_per_page' => ['sometimes', 'integer', 'min:4', 'max:48'],
+            'display_categories' => ['sometimes', 'boolean'],
+            'display_seach_bar' => ['sometimes', 'boolean'],
+            'display_cart' => ['sometimes', 'boolean'],
+            'cart_editing_policy' => ['sometimes', Rule::enum(CartEditingPolicy::class)],
+            'checkout_editing_policy' => [
+                'sometimes',
+                Rule::in([CartEditingPolicy::Disabled->value]),
+            ],
+            'display_cart_item_images' => ['sometimes', 'boolean'],
+            'scanner_category_validation_enabled' => ['sometimes', 'boolean'],
+        ];
+    }
+}

app/Domains/Tenant/Resources/AdminApp/WebsiteExtraResource.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Domains\Tenant\Resources\AdminApp;
+
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Attachable\Models\AttachmentCrop;
+use App\Domains\Tenant\Models\WebsiteExtra;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/**
+ * @mixin WebsiteExtra
+ */
+class WebsiteExtraResource extends JsonResource
+{
+    /**
+     * @return array<string, mixed>
+     */
+    public function toArray(Request $request): array
+    {
+        return [
+            'codigo' => $this->websiteTypeExtra->codigo,
+            'nombre' => $this->websiteTypeExtra->nombre,
+            'descripcion' => $this->websiteTypeExtra->descripcion,
+            'is_required' => $this->websiteTypeExtra->is_required,
+            'is_enabled' => $this->is_enabled,
+            'request_rules' => $this->websiteTypeExtra->config_schema['request_rules'] ?? [],
+            'config' => $this->formatConfig(
+                $this->resolvedConfig(),
+                fn (Attachment $attachment): string => $attachment->key
+            ),
+            'resolved_config' => $this->formatConfig(
+                $this->resolvedAdminConfig(),
+                fn (Attachment $attachment): string => $attachment->getTemporaryUrl(1440)
+            ),
+        ];
+    }
+
+    private function resolvedAdminConfig(): mixed
+    {
+        $config = $this->resolvedConfig();
+
+        if (
+            $this->websiteTypeExtra->codigo !== 'heroConfig'
+            || ! is_array($config)
+            || ! ($config['background_image_id'] ?? null) instanceof Attachment
+        ) {
+            return $config;
+        }
+
+        $attachment = $config['background_image_id'];
+        $fullRange = ['start_percentage' => 0.0, 'end_percentage' => 100.0];
+        $crops = $attachment->cropVariants->keyBy('variant');
+        $config['background_image_id'] = [
+            'url' => $attachment->getTemporaryUrl(1440),
+            'crops' => collect(AttachmentCrop::VARIANTS)->mapWithKeys(
+                function (string $variant) use ($crops, $fullRange): array {
+                    $crop = $crops->get($variant);
+
+                    return [$variant => [
+                        'crop_horizontal' => $crop?->crop_horizontal ?? $fullRange,
+                        'crop_vertical' => $crop?->crop_vertical ?? $fullRange,
+                    ]];
+                }
+            )->all(),
+        ];
+
+        return $config;
+    }
+
+    private function formatConfig(mixed $value, callable $formatAttachment): mixed
+    {
+        if ($value instanceof Attachment) {
+            return $formatAttachment($value);
+        }
+
+        if (! is_array($value)) {
+            return $value;
+        }
+
+        return array_map(
+            fn (mixed $item): mixed => $this->formatConfig($item, $formatAttachment),
+            $value
+        );
+    }
+}

app/Domains/Tenant/Services/WebsiteTypeService.php

@@ -82,7 +82,6 @@ class WebsiteTypeService
                     && $previousLogo->id !== $websiteType->site_logo
                     && $previousLogo->id !== $websiteType->footer_logo
                     && $previousLogo->id !== $websiteType->favicon_id
-                    && ! $this->isReferencedByWebsiteType($previousLogo)
                 ) {
                     $this->attachmentService->delete($previousLogo);
                 }
@@ -91,16 +90,4 @@ class WebsiteTypeService
             return $websiteType;
         });
     }
-
-    private function isReferencedByWebsiteType(Attachment $attachment): bool
-    {
-        return WebsiteType::query()
-            ->where(function ($query) use ($attachment): void {
-                $query
-                    ->where('site_logo', $attachment->id)
-                    ->orWhere('footer_logo', $attachment->id)
-                    ->orWhere('favicon_id', $attachment->id);
-            })
-            ->exists();
-    }
 }

app/Domains/Tenant/routes/adminapp.php

@@ -7,6 +7,7 @@ Route::prefix('v1/adminapp/tenant')
     ->middleware(['auth:sanctum', 'adminapp.tenant'])
     ->group(function (): void {
         Route::get('website-extras', [WebsiteExtraController::class, 'show']);
+        Route::get('website-extras/{websiteExtraCode}', [WebsiteExtraController::class, 'showExtra']);
         Route::put('website-extras/{websiteExtraCode}', [WebsiteExtraController::class, 'update']);
         Route::patch('website-extras/{websiteExtraCode}/toggle', [WebsiteExtraController::class, 'toggle']);
     });

app/Domains/Tenant/routes/api.php

@@ -1,3 +1,8 @@
 <?php
 
+use App\Domains\Tenant\Controllers\TenantController;
+use Illuminate\Support\Facades\Route;
+
+Route::apiResource('tenants', TenantController::class);
+
 require __DIR__.'/adminapp.php';

app/Domains/Ticket/Listeners/GenerateTicketsForPaidPurchase.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Ticket\Listeners;
 
 use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Notification\Events\TicketsAvailable;
 use App\Domains\Purchase\Events\PurchasePaid;
 use App\Domains\Purchase\Models\Purchase;
 use App\Domains\Ticket\Exceptions\TicketGenerationException;
@@ -20,6 +21,8 @@ class GenerateTicketsForPaidPurchase
             ->with(['user', 'items'])
             ->findOrFail($event->purchaseId);
         $user = $purchase->user;
+        $ticketIds = [];
+
         foreach ($purchase->items as $purchaseItem) {
             $catalogItem = CatalogItem::query()
                 ->where('tenant_code', $purchase->tenant_codigo)
@@ -37,13 +40,19 @@ class GenerateTicketsForPaidPurchase
                 throw TicketGenerationException::purchaseWithoutUser($purchase);
             }
 
-            $this->ticketGenerator->generate(
+            $generatedTickets = $this->ticketGenerator->generate(
                 $catalogItem,
                 $user,
                 $purchaseItem->cantidad,
                 $purchaseItem->source_variant_id,
                 $purchase->getKey(),
             );
+
+            array_push($ticketIds, ...$generatedTickets->pluck('id')->all());
+        }
+
+        if ($ticketIds !== []) {
+            TicketsAvailable::dispatch($purchase->getKey(), $ticketIds);
         }
     }
 

app/Domains/Ticket/documentacion/README.md

@@ -21,7 +21,7 @@ vigente, vencido o usado, y resuelve sus fechas efectivas de inicio y fin sin pe
 1. `Purchase` emite `PurchasePaid` al confirmarse el pago.
 2. `GenerateTicketsForPaidPurchase` atiende el evento.
 3. `TicketGeneratorService` crea los tickets requeridos según ítems, cantidades y vigencia.
-4. `Notification` envía la confirmación de compra después de la generación y adjunta los tickets cuando existen.
+4. El flujo puede emitir disponibilidad para que `Notification` informe al comprador.
 
 ## Endpoints
 

app/Providers/AppServiceProvider.php

@@ -3,9 +3,11 @@
 namespace App\Providers;
 
 use App\Domains\Notification\Events\PasswordResetRequested;
+use App\Domains\Notification\Events\TicketsAvailable;
 use App\Domains\Notification\Events\UserRegistered;
 use App\Domains\Notification\Listeners\SendPasswordResetEmail;
-use App\Domains\Notification\Listeners\SendPurchaseConfirmedEmail;
+use App\Domains\Notification\Listeners\SendPurchasePaidEmail;
+use App\Domains\Notification\Listeners\SendTicketsAvailableEmail;
 use App\Domains\Notification\Listeners\SendWelcomeEmail;
 use App\Domains\Purchase\Events\PurchasePaid;
 use App\Domains\Ticket\Listeners\GenerateTicketsForPaidPurchase;
@@ -31,8 +33,9 @@ class AppServiceProvider extends ServiceProvider
      */
     public function boot(): void
     {
+        Event::listen(PurchasePaid::class, SendPurchasePaidEmail::class);
         Event::listen(PurchasePaid::class, GenerateTicketsForPaidPurchase::class);
-        Event::listen(PurchasePaid::class, SendPurchaseConfirmedEmail::class);
+        Event::listen(TicketsAvailable::class, SendTicketsAvailableEmail::class);
         Event::listen(UserRegistered::class, SendWelcomeEmail::class);
         Event::listen(PasswordResetRequested::class, SendPasswordResetEmail::class);
 

config/auth.php

@@ -96,7 +96,7 @@ return [
         'users' => [
             'provider' => 'users',
             'table' => env('AUTH_PASSWORD_RESET_TOKEN_TABLE', 'password_reset_tokens'),
-            'expire' => (int) env('AUTH_PASSWORD_RESET_EXPIRATION_MINUTES', 60),
+            'expire' => 60,
             'throttle' => 60,
         ],
     ],

config/purchase.php

@@ -2,4 +2,10 @@
 
 return [
     'checkout_expiration_minutes' => (int) env('PURCHASE_CHECKOUT_EXPIRATION_MINUTES', 30),
+
+    'payment_expiration_minutes' => [
+        'qr' => (int) env('PURCHASE_QR_EXPIRATION_MINUTES', 15),
+        'telepagos' => (int) env('PURCHASE_TELEPAGOS_EXPIRATION_MINUTES', 30),
+        'transfer' => (int) env('PURCHASE_TRANSFER_EXPIRATION_MINUTES', 1440),
+    ],
 ];

database/migrations/2026_08_25_010000_add_expires_at_to_reset_password_attempts_table.php

@@ -1,32 +0,0 @@
-<?php
-
-use App\Domains\Auth\Models\ResetPasswordAttempt;
-use Illuminate\Database\Migrations\Migration;
-use Illuminate\Database\Schema\Blueprint;
-use Illuminate\Support\Facades\DB;
-use Illuminate\Support\Facades\Schema;
-
-return new class extends Migration
-{
-    public function up(): void
-    {
-        Schema::table('reset_password_attempts', function (Blueprint $table): void {
-            $table->timestamp('expires_at')->nullable()->after('status');
-        });
-
-        // Attempts created before this migration did not have an expiration instant.
-        DB::table('reset_password_attempts')
-            ->whereIn('status', [
-                ResetPasswordAttempt::STATUS_PENDING,
-                ResetPasswordAttempt::STATUS_VALIDATED,
-            ])
-            ->update(['status' => ResetPasswordAttempt::STATUS_EXPIRED]);
-    }
-
-    public function down(): void
-    {
-        Schema::table('reset_password_attempts', function (Blueprint $table): void {
-            $table->dropColumn('expires_at');
-        });
-    }
-};

database/migrations/2026_08_26_000000_set_website_type_favicon.php

@@ -1,96 +0,0 @@
-<?php
-
-use Illuminate\Database\Migrations\Migration;
-use Illuminate\Support\Facades\DB;
-use Illuminate\Support\Facades\Storage;
-use Illuminate\Support\Str;
-
-return new class extends Migration
-{
-    private const FILENAME = 'onticket_favicon.svg';
-
-    /** @var list<string> */
-    private const WEBSITE_TYPE_CODES = ['shopit', 'onticket'];
-
-    public function up(): void
-    {
-        $websiteTypes = DB::table('website_type')
-            ->whereIn('codigo', self::WEBSITE_TYPE_CODES)
-            ->get(['codigo', 'favicon_id']);
-
-        if ($websiteTypes->isEmpty()) {
-            return;
-        }
-
-        $faviconIds = $websiteTypes
-            ->pluck('favicon_id')
-            ->filter()
-            ->unique()
-            ->values();
-
-        if (
-            $faviconIds->count() === 1
-            && DB::table('attachments')
-                ->where('id', $faviconIds->first())
-                ->where('filename', self::FILENAME)
-                ->exists()
-            && $websiteTypes->every(
-                fn (object $websiteType): bool => $websiteType->favicon_id === $faviconIds->first()
-            )
-        ) {
-            return;
-        }
-
-        $sourcePath = public_path('images/website_types/'.self::FILENAME);
-
-        if (! is_file($sourcePath)) {
-            throw new RuntimeException("Favicon not found at path: {$sourcePath}");
-        }
-
-        $contents = file_get_contents($sourcePath);
-
-        if ($contents === false) {
-            throw new RuntimeException("Could not read favicon at path: {$sourcePath}");
-        }
-
-        $key = (string) Str::uuid();
-        $storedPath = "website-types/{$key}.svg";
-
-        if (! Storage::disk('s3')->put($storedPath, $contents)) {
-            throw new RuntimeException("Could not store favicon at path: {$storedPath}");
-        }
-
-        try {
-            DB::transaction(function () use ($contents, $key, $storedPath): void {
-                $attachmentId = DB::table('attachments')->insertGetId([
-                    'key' => $key,
-                    'path' => $storedPath,
-                    'filename' => self::FILENAME,
-                    'type' => 'image',
-                    'mime_type' => 'image/svg+xml',
-                    'extension' => 'svg',
-                    'size' => strlen($contents),
-                    'created_at' => now(),
-                    'updated_at' => now(),
-                ]);
-
-                DB::table('website_type')
-                    ->whereIn('codigo', self::WEBSITE_TYPE_CODES)
-                    ->update([
-                        'favicon_id' => $attachmentId,
-                        'updated_at' => now(),
-                    ]);
-            });
-        } catch (Throwable $throwable) {
-            Storage::disk('s3')->delete($storedPath);
-
-            throw $throwable;
-        }
-    }
-
-    public function down(): void
-    {
-        // The shared attachment may be in use outside these website types.
-        // Keep this data migration irreversible to avoid deleting an active asset.
-    }
-};

database/seeders/DesfilePuraTendenciaSeeder.php

@@ -191,7 +191,6 @@ class DesfilePuraTendenciaSeeder extends Seeder
 
         FeaturedGroup::query()->create([
             'tenant_code' => self::TENANT_CODE,
-            'code' => 'entradas',
             'source_type' => FeaturedGroupSource::All,
             'category_id' => null,
             'product_layout' => ProductLayout::TicketSelector,

database/seeders/FiestaFutbolInfantilProductSeeder.php

@@ -144,7 +144,6 @@ class FiestaFutbolInfantilProductSeeder extends Seeder
 
         FeaturedGroup::query()->create([
             'tenant_code' => $tenant->codigo,
-            'code' => 'productos',
             'source_type' => FeaturedGroupSource::All,
             'category_id' => null,
             'product_layout' => ProductLayout::Row,

database/seeders/ProductCatalogFromImagesSeeder.php

@@ -171,7 +171,6 @@ class ProductCatalogFromImagesSeeder extends Seeder
 
         FeaturedGroup::query()->create([
             'tenant_code' => $tenant->codigo,
-            'code' => 'productos',
             'source_type' => FeaturedGroupSource::All,
             'product_layout' => ProductLayout::ColumnWithImage,
             'group_layout' => GroupLayout::Paginated,
@@ -181,7 +180,6 @@ class ProductCatalogFromImagesSeeder extends Seeder
 
         $carouselGroup = FeaturedGroup::query()->create([
             'tenant_code' => $tenant->codigo,
-            'code' => 'productos-destacados',
             'source_type' => FeaturedGroupSource::Manual,
             'product_layout' => ProductLayout::ColumnWithImage,
             'group_layout' => GroupLayout::Carousel,

database/seeders/WebsiteTypeSeeder.php

@@ -36,7 +36,6 @@ class WebsiteTypeSeeder extends Seeder
                 ...self::PRESENTATION,
                 'site_logo' => $this->onTicketLogo(),
                 'footer_logo' => $this->onTicketFooterLogo(),
-                'favicon' => $this->onTicketFavicon(),
             ],
         );
 
@@ -71,7 +70,6 @@ class WebsiteTypeSeeder extends Seeder
                 ...self::PRESENTATION,
                 'site_logo' => $this->onTicketLogo(),
                 'footer_logo' => $this->onTicketFooterLogo(),
-                'favicon' => $shopIt->favicon()->firstOrFail()->key,
             ],
         );
 
@@ -177,21 +175,4 @@ class WebsiteTypeSeeder extends Seeder
             true,
         );
     }
-
-    private function onTicketFavicon(): UploadedFile
-    {
-        $path = public_path('images/website_types/onticket_favicon.svg');
-
-        if (! file_exists($path)) {
-            throw new RuntimeException("OnTicket favicon not found at path: {$path}");
-        }
-
-        return new UploadedFile(
-            $path,
-            'onticket_favicon.svg',
-            'image/svg+xml',
-            null,
-            true,
-        );
-    }
 }

lang/en/api.php

@@ -12,7 +12,6 @@ return [
         'password_reset_invalid' => 'The password recovery request is invalid or has already been used.',
         'password_updated' => 'Password updated successfully.',
         'reset_code_invalid' => 'The code you entered is invalid.',
-        'reset_code_expired' => 'The password recovery code expired. Request a new one.',
         'reset_code_valid' => 'Code validated successfully.',
         'invalid_tenant_or_return_url' => 'The tenant or return URL is invalid.',
         'request_expired' => 'The authentication request expired. Please try again.',

lang/es/api.php

@@ -12,7 +12,6 @@ return [
         'password_reset_invalid' => 'La solicitud de recuperación es inválida o ya fue utilizada.',
         'password_updated' => 'Contraseña modificada correctamente.',
         'reset_code_invalid' => 'El código ingresado es inválido.',
-        'reset_code_expired' => 'El código de recuperación expiró. Solicitá uno nuevo.',
         'reset_code_valid' => 'Código validado correctamente.',
         'invalid_tenant_or_return_url' => 'El tenant o la URL de retorno no son válidos.',
         'request_expired' => 'La solicitud de autenticación expiró. Intenta nuevamente.',

postman/attachable-s3-testing.postman_collection.json

@@ -0,0 +1,95 @@
+{
+  "info": {
+    "_postman_id": "8faefdb8-734a-4262-a3b6-4d49e56ea901",
+    "name": "Storage Test S3",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "variable": [
+    {
+      "key": "base_url",
+      "value": "http://127.0.0.1:8000"
+    },
+    {
+      "key": "expires_in_minutes",
+      "value": "10"
+    },
+    {
+      "key": "path",
+      "value": ""
+    }
+  ],
+  "item": [
+    {
+      "name": "Upload Test File",
+      "request": {
+        "method": "POST",
+        "header": [],
+        "body": {
+          "mode": "formdata",
+          "formdata": [
+            {
+              "key": "file",
+              "type": "file",
+              "src": []
+            },
+            {
+              "key": "directory",
+              "value": "testing/manual",
+              "type": "text"
+            },
+            {
+              "key": "expires_in_minutes",
+              "value": "{{expires_in_minutes}}",
+              "type": "text"
+            }
+          ]
+        },
+        "url": {
+          "raw": "{{base_url}}/api/storage-test/s3/upload",
+          "host": [
+            "{{base_url}}"
+          ],
+          "path": [
+            "api",
+            "storage-test",
+            "s3",
+            "upload"
+          ]
+        },
+        "description": "Sube un archivo al disco s3 y devuelve el path junto con una temporary_url."
+      },
+      "response": []
+    },
+    {
+      "name": "Generate Temporary URL",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/storage-test/s3/temporary-url?path={{path}}&expires_in_minutes={{expires_in_minutes}}",
+          "host": [
+            "{{base_url}}"
+          ],
+          "path": [
+            "api",
+            "storage-test",
+            "s3",
+            "temporary-url"
+          ],
+          "query": [
+            {
+              "key": "path",
+              "value": "{{path}}"
+            },
+            {
+              "key": "expires_in_minutes",
+              "value": "{{expires_in_minutes}}"
+            }
+          ]
+        },
+        "description": "Genera una URL temporal para un path ya existente en S3."
+      },
+      "response": []
+    }
+  ]
+}

postman/generate-shopit-collection.php

@@ -67,7 +67,18 @@ function bodyFor(string $method, string $uri): ?array
         'POST api/password/reset-attempts' => ['tenant_codigo' => '{{tenant_code}}', 'email' => '{{user_email}}'],
         'POST api/password/reset-attempts/validate' => ['email' => '{{user_email}}', 'codigo' => '{{reset_code}}'],
         'POST api/password/reset' => ['email' => '{{user_email}}', 'codigo' => '{{reset_code}}', 'password' => '{{user_password}}', 'password_confirmation' => '{{user_password}}'],
+        'POST api/clients' => ['code' => 'cliente-demo', 'name' => 'Cliente Demo'],
+        'PUT api/clients/{client}' => ['code' => 'cliente-demo', 'name' => 'Cliente Demo Actualizado'],
+        'PATCH api/clients/{client}' => ['name' => 'Cliente Demo Actualizado'],
+        'POST api/integrations' => ['integration_code' => 'telepagos', 'name' => 'Telepagos', 'url' => 'https://api.example.com', 'integration_data_schema' => ['api_key' => ['required', 'string']], 'requires_client_configuration' => true],
+        'PUT api/integrations/{integration}' => ['name' => 'Telepagos', 'url' => 'https://api.example.com', 'requires_client_configuration' => true],
         'PUT api/clients/{client}/integrations/{integration_code}' => ['integration_data' => ['api_key' => 'replace-me']],
+        'POST api/menues' => ['code' => 'demo', 'label' => 'Demo', 'parent_menu_code' => null, 'content_type' => 'static', 'static_content_schema' => ['title' => ['required', 'string']], 'route' => '/demo'],
+        'PUT api/menues/{menue}' => ['label' => 'Demo actualizado', 'route' => '/demo'],
+        'PATCH api/menues/{menue}' => ['label' => 'Demo actualizado'],
+        'POST api/{tenant_code}/menues/{menu_code}' => ['static_content' => ['title' => 'Contenido demo']],
+        'POST api/webhooks/telepagos/{client}' => ['id' => 'payment-id-demo'],
+        'POST api/{tenant_code}/mail-test/send' => ['to' => 'destinatario@example.com', 'subject' => 'Prueba ShopIt', 'message' => 'Correo de prueba enviado desde Postman.'],
         'POST api/tenants/{tenant:codigo}/cart/items' => ['catalog_item_id' => '{{catalog_item_id}}', 'variant_id' => '{{variant_id}}', 'cantidad' => 1],
         'PATCH api/tenants/{tenant:codigo}/cart/items/{cartItem}' => ['cantidad' => 2, 'variant_id' => '{{variant_id}}'],
         'POST api/tenants/{tenant:codigo}/catalog-items/{catalogItem}/variant-options' => ['selected_values' => ['color' => 'azul'], 'cart_item_id' => '{{cart_item_id}}'],
@@ -81,8 +92,11 @@ function bodyFor(string $method, string $uri): ?array
         'POST api/v1/adminapp/password/reset-attempts/validate' => ['email' => '{{admin_email}}', 'codigo' => '{{reset_code}}'],
         'POST api/v1/adminapp/password/reset' => ['email' => '{{admin_email}}', 'codigo' => '{{reset_code}}', 'password' => '{{admin_password}}', 'password_confirmation' => '{{admin_password}}'],
         'PUT api/v1/adminapp/tenant/event' => ['title' => 'Evento Demo', 'location' => 'Buenos Aires', 'dates' => [['date' => '2026-12-01', 'start_time' => '18:00', 'end_time' => '23:00']], 'social_media' => [['code' => 'instagram', 'url' => 'https://instagram.com/example', 'orden' => 0]]],
+        'POST api/v1/adminapp/tenant/featured-groups' => ['category_name' => 'Destacados', 'is_featured' => true],
+        'PUT api/v1/adminapp/tenant/featured-groups/{featuredGroup}' => ['category_name' => 'Destacados', 'is_featured' => true],
         'POST api/v1/adminapp/tenant/staff' => ['nombre_apellido' => 'Operador Demo', 'dni' => '30123456', 'email' => 'operador@example.com', 'category_ids' => [1]],
         'PUT api/v1/adminapp/tenant/staff/{staff}' => ['nombre_apellido' => 'Operador Demo', 'dni' => '30123456', 'email' => 'operador@example.com', 'category_ids' => [1]],
+        'PATCH api/v1/adminapp/tenant/staff/{staff}' => ['nombre_apellido' => 'Operador Demo', 'dni' => '30123456', 'email' => 'operador@example.com', 'category_ids' => [1]],
         'PUT api/v1/adminapp/tenant/website-extras/{websiteExtraCode}' => ['enabled' => true, 'content' => ['title' => 'Contenido demo']],
         'PATCH api/v1/adminapp/tenant/website-extras/{websiteExtraCode}/toggle' => ['enabled' => true],
         'POST api/v1/adminapp/tenant/accommodations' => ['variants' => [['title' => 'Habitación doble', 'description' => 'Dos personas', 'stock' => 10, 'price' => 100000]]],
@@ -148,6 +162,10 @@ function bodyFor(string $method, string $uri): ?array
         ]);
     }
 
+    if ($key === 'POST api/storage-test/s3/upload') {
+        return formDataBody(['path' => 'postman/test-file.png', 'expires_in_minutes' => '60'], ['file']);
+    }
+
     if ($key === 'POST api/v1/adminapp/tenant/desfile/entries/image') {
         return formDataBody(['is_enabled' => '1'], ['image']);
     }
@@ -176,6 +194,7 @@ function queryFor(string $uri): array
             ['key' => 'per_page', 'value' => '20'],
         ],
         'api/v1/scanner/tickets' => [['key' => 'q', 'value' => '', 'disabled' => true], ['key' => 'page', 'value' => '1'], ['key' => 'per_page', 'value' => '20']],
+        'api/storage-test/s3/temporary-url' => [['key' => 'path', 'value' => '{{s3_path}}'], ['key' => 'expires_in_minutes', 'value' => '60']],
         default => [],
     };
 }
@@ -194,6 +213,14 @@ function folderFor(string $uri, string $action): array
         return ['Scanner API', $domain];
     }
 
+    if (str_starts_with($uri, 'api/webhooks/')) {
+        return ['Webhooks', $domain];
+    }
+
+    if (in_array($domain, ['StorageTest', 'MailTest'], true)) {
+        return ['Developer Utilities', $domain];
+    }
+
     if (in_array($domain, ['Client', 'Integration', 'Menu', 'Tenant'], true) && ! str_contains($uri, '{tenant:codigo}')) {
         return ['Platform Management', $domain];
     }
@@ -241,7 +268,8 @@ function pathFor(string $uri): string
 {
     $variables = [
         'tenant:codigo' => 'tenant_code', 'tenant' => 'tenant_id', 'client' => 'client_id',
-        'integration_code' => 'integration_code', 'tenant_code' => 'tenant_code', 'catalogItem' => 'catalog_item_id',
+        'integration_code' => 'integration_code', 'integration' => 'integration_id', 'menue' => 'menu_id',
+        'menu_code' => 'menu_code', 'tenant_code' => 'tenant_code', 'catalogItem' => 'catalog_item_id',
         'featuredGroup' => 'featured_group_id', 'category' => 'category_id', 'cartItem' => 'cart_item_id',
         'compra' => 'purchase_id', 'item' => 'purchase_item_id', 'dominio' => 'tenant_domain',
         'sale' => 'sale_id', 'staff' => 'staff_id', 'websiteExtraCode' => 'website_extra_code',
@@ -392,13 +420,14 @@ $variables = [
     'admin_email' => 'admin@example.com', 'admin_password' => 'Password!123',
     'scanner_email' => 'scanner@example.com', 'scanner_password' => 'Password!123',
     'tenant_code' => 'demo', 'tenant_id' => '1', 'tenant_domain' => 'demo.test',
-    'client_id' => '1', 'integration_code' => 'telepagos',
-    'catalog_item_id' => '1', 'variant_id' => '1',
+    'client_id' => '1', 'integration_id' => '1', 'integration_code' => 'telepagos',
+    'menu_id' => '1', 'menu_code' => 'demo', 'catalog_item_id' => '1', 'variant_id' => '1',
     'category_id' => '1', 'featured_group_id' => '1', 'cart_id' => '1', 'cart_item_id' => '1',
     'purchase_id' => '1', 'purchase_item_id' => '1', 'sale_id' => '1', 'staff_id' => '1',
     'website_extra_code' => 'hero', 'accommodation_id' => '1', 'entry_id' => '1', 'food_id' => '1',
     'merchandise_id' => '1', 'ticket_uuid' => '00000000-0000-0000-0000-000000000000',
     'oauth_code' => '00000000-0000-0000-0000-000000000000', 'reset_code' => '1234',
+    's3_path' => 'postman/test-file.png',
 ];
 
 $collection = [

public/images/website_types/onticket_favicon.svg

@@ -1,3 +0,0 @@
-<svg width="63" height="36" viewBox="0 0 63 36" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M44.64 0H17.94C8.05 0 0 8.05 0 17.94C0 27.83 8.05 35.88 17.94 35.88H44.64C54.53 35.88 62.58 27.83 62.58 17.94C62.58 8.05 54.53 0 44.64 0ZM44.62 31.78C36.98 31.78 30.79 25.59 30.79 17.95C30.79 10.31 36.98 4.12 44.62 4.12C52.26 4.12 58.45 10.31 58.45 17.95C58.45 25.59 52.26 31.78 44.62 31.78Z" fill="#FF7006"/>
-</svg>

resources/views/mail/notifications/purchase-paid.blade.php

@@ -1,4 +1,4 @@
-<h1 style="margin: 0 0 20px;">¡Compra realizada con éxito!</h1>
+<h1 style="margin: 0 0 20px;">¡Recibimos tu pago!</h1>
 <p>La compra <strong>#{{ $purchase->id }}</strong> fue confirmada correctamente.</p>
 <table role="presentation" style="width: 100%; border-collapse: collapse; margin: 20px 0;">
     @foreach ($purchase->items as $item)
@@ -10,6 +10,3 @@
     @endforeach
 </table>
 <p style="font-size: 18px;"><strong>Total pagado: ${{ number_format((float) $purchase->total, 2, ',', '.') }}</strong></p>
-@if ($tickets->isNotEmpty())
-    <p><strong>Tus tickets ya están disponibles</strong></p>
-@endif

resources/views/mail/notifications/tickets-available.blade.php

@@ -0,0 +1,8 @@
+<h1 style="margin: 0 0 20px;">Tus tickets ya están disponibles</h1>
+<p>Generamos {{ $tickets->count() }} {{ $tickets->count() === 1 ? 'ticket' : 'tickets' }} para la compra <strong>#{{ $purchase->id }}</strong>.</p>
+<p>{{ $tickets->count() === 1 ? 'El ticket está adjunto' : 'Los tickets están adjuntos' }} a este correo en formato PDF.</p>
+<ul style="padding-left: 20px;">
+    @foreach ($tickets as $ticket)
+        <li style="margin-bottom: 8px;">{{ $ticket->name }}</li>
+    @endforeach
+</ul>

routes/api.php

@@ -3,11 +3,15 @@
 require __DIR__.'/../app/Domains/Auth/routes/api.php';
 require __DIR__.'/../app/Domains/Catalog/routes/api.php';
 require __DIR__.'/../app/Domains/Cart/routes/api.php';
+require __DIR__.'/../app/Domains/StorageTest/routes/api.php';
+require __DIR__.'/../app/Domains/MailTest/routes/api.php';
 require __DIR__.'/../app/Domains/Purchase/routes/api.php';
 require __DIR__.'/../app/Domains/Sale/routes/api.php';
 require __DIR__.'/../app/Domains/Bootstrap/routes/api.php';
 require __DIR__.'/../app/Domains/Tenant/routes/api.php';
+require __DIR__.'/../app/Domains/Client/routes/api.php';
 require __DIR__.'/../app/Domains/Integration/routes/api.php';
+require __DIR__.'/../app/Domains/Menu/routes/api.php';
 require __DIR__.'/../app/Domains/Ticket/routes/api.php';
 require __DIR__.'/../app/Domains/Event/routes/api.php';
 require __DIR__.'/../app/Domains/Forms/routes/api.php';

tests/Feature/Auth/CreateResetPasswordAttemptControllerTest.php

@@ -69,10 +69,6 @@ class CreateResetPasswordAttemptControllerTest extends TestCase
         $this->assertTrue($attempt->user->is($user));
         $this->assertMatchesRegularExpression('/^\d{4}$/', $attempt->codigo);
         $this->assertSame(ResetPasswordAttempt::STATUS_PENDING, $attempt->status);
-        $this->assertTrue($attempt->expires_at->between(
-            now()->addMinutes(59),
-            now()->addMinutes(60),
-        ));
         Event::assertDispatched(
             PasswordResetRequested::class,
             fn (PasswordResetRequested $event): bool => $event->attemptId === $attempt->id

tests/Feature/Auth/ResetPasswordAttemptTest.php

@@ -18,9 +18,7 @@ class ResetPasswordAttemptTest extends TestCase
             'id',
             'user_id',
             'codigo',
-            'reason',
             'status',
-            'expires_at',
         ], Schema::getColumnListing('reset_password_attempts'));
     }
 
@@ -30,14 +28,12 @@ class ResetPasswordAttemptTest extends TestCase
 
         $attempt = $user->resetPasswordAttempts()->create([
             'codigo' => '123456',
-            'expires_at' => now()->addHour(),
         ]);
 
         $this->assertSame(ResetPasswordAttempt::STATUS_PENDING, $attempt->status);
         $this->assertTrue($attempt->user->is($user));
         $this->assertTrue($user->resetPasswordAttempts->contains($attempt));
         $this->assertFalse($attempt->usesTimestamps());
-        $this->assertTrue($attempt->expires_at->isFuture());
         $this->assertArrayNotHasKey('codigo', $attempt->toArray());
     }
 

tests/Feature/Auth/ResetPasswordControllerTest.php

@@ -99,30 +99,6 @@ class ResetPasswordControllerTest extends TestCase
         $this->assertSame(ResetPasswordAttempt::STATUS_USED, $attempt->fresh()->status);
     }
 
-    public function test_an_expired_validated_attempt_cannot_reset_the_password(): void
-    {
-        $user = User::factory()->create([
-            'email' => 'ada@example.com',
-            'password' => 'OldSecret!123',
-        ]);
-        $attempt = $user->resetPasswordAttempts()->create([
-            'codigo' => '1234',
-            'status' => ResetPasswordAttempt::STATUS_VALIDATED,
-            'expires_at' => now()->subSecond(),
-        ]);
-
-        $this->postJson('/api/password/reset', [
-            'email' => 'ada@example.com',
-            'codigo' => '1234',
-            'password' => 'NewSecret!456',
-            'password_confirmation' => 'NewSecret!456',
-        ])->assertUnprocessable()
-            ->assertJsonValidationErrors('codigo');
-
-        $this->assertTrue(Hash::check('OldSecret!123', $user->fresh()->password));
-        $this->assertSame(ResetPasswordAttempt::STATUS_EXPIRED, $attempt->fresh()->status);
-    }
-
     public function test_it_validates_password_confirmation_and_strength(): void
     {
         $this->postJson('/api/password/reset', [

tests/Feature/Auth/ValidateResetPasswordAttemptControllerTest.php

@@ -49,27 +49,6 @@ class ValidateResetPasswordAttemptControllerTest extends TestCase
         );
     }
 
-    public function test_it_expires_an_attempt_and_returns_the_expired_code_message(): void
-    {
-        $user = User::factory()->create(['email' => 'ada@example.com']);
-        $attempt = $user->resetPasswordAttempts()->create([
-            'codigo' => '1234',
-            'expires_at' => now()->subSecond(),
-        ]);
-
-        $this->postJson('/api/password/reset-attempts/validate', [
-            'email' => 'ada@example.com',
-            'codigo' => '1234',
-        ])->assertUnprocessable()
-            ->assertJsonValidationErrors('codigo')
-            ->assertJsonPath('errors.codigo.0', __('api.auth.reset_code_expired'));
-
-        $this->assertSame(
-            ResetPasswordAttempt::STATUS_EXPIRED,
-            $attempt->fresh()->status,
-        );
-    }
-
     public function test_it_rejects_an_expired_or_already_validated_attempt(): void
     {
         $user = User::factory()->create(['email' => 'ada@example.com']);

tests/Feature/Catalog/BundleCatalogItemTest.php

@@ -199,7 +199,7 @@ class BundleCatalogItemTest extends TestCase
             'email' => 'bundle@example.com',
         ]);
         $purchase->update(['payment_method' => 'transfer']);
-        $checkoutService->confirmPurchase($purchase);
+        $checkoutService->confirmPurchase($checkoutService->completePurchase($purchase));
 
         $this->assertDatabaseCount('compra_items', 1);
         $this->assertDatabaseHas('compra_items', [

tests/Feature/Catalog/CatalogSchemaTest.php

@@ -96,7 +96,6 @@ class CatalogSchemaTest extends TestCase
         $this->assertEqualsCanonicalizing([
             'id',
             'tenant_code',
-            'code',
             'source_type',
             'category_id',
             'product_layout',

tests/Feature/Catalog/OnTicketFeaturedGroupControllerTest.php

@@ -0,0 +1,266 @@
+<?php
+
+namespace Tests\Feature\Catalog;
+
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Catalog\Enums\FeaturedGroupSource;
+use App\Domains\Catalog\Enums\GroupLayout;
+use App\Domains\Catalog\Enums\ProductLayout;
+use App\Domains\Catalog\Models\Category;
+use App\Domains\Catalog\Models\FeaturedGroup;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Tenant\Models\WebsiteType;
+use Database\Seeders\AuthorizationSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class OnTicketFeaturedGroupControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->seed(AuthorizationSeeder::class);
+        WebsiteType::query()->create([
+            'codigo' => 'onticket',
+            'nombre' => 'OnTicket',
+        ]);
+        WebsiteType::query()->create([
+            'codigo' => 'shopit',
+            'nombre' => 'Shopit',
+        ]);
+    }
+
+    public function test_authentication_is_required(): void
+    {
+        $this->getJson('/api/v1/adminapp/tenant/featured-groups')->assertUnauthorized();
+        $this->postJson('/api/v1/adminapp/tenant/featured-groups', $this->payload())
+            ->assertUnauthorized();
+        $this->putJson('/api/v1/adminapp/tenant/featured-groups/1', $this->payload())
+            ->assertUnauthorized();
+    }
+
+    public function test_index_returns_only_category_groups_for_the_onticket_tenant(): void
+    {
+        $tenant = $this->createTenant('acme');
+        $otherTenant = $this->createTenant('other');
+        $first = $this->createCategoryGroup($tenant, 'Food', order: 2);
+        $second = $this->createCategoryGroup($tenant, 'Tickets', order: 1);
+        $this->createCategoryGroup($otherTenant, 'Other tenant');
+        FeaturedGroup::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'source_type' => FeaturedGroupSource::All,
+            'product_layout' => ProductLayout::Row,
+            'group_layout' => GroupLayout::Paginated,
+            'group_name' => 'All products',
+            'group_order' => 0,
+        ]);
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->getJson('/api/v1/adminapp/tenant/featured-groups')
+            ->assertOk()
+            ->assertJsonCount(2, 'data')
+            ->assertJsonPath('data.0.id', $second->id)
+            ->assertJsonPath('data.0.category_name', 'Tickets')
+            ->assertJsonPath('data.1.id', $first->id)
+            ->assertJsonMissing(['category_name' => 'Other tenant'])
+            ->assertJsonMissing(['group_name' => 'All products']);
+    }
+
+    public function test_store_creates_a_category_and_a_featured_horizontal_group(): void
+    {
+        $tenant = $this->createTenant('acme');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $response = $this->postJson('/api/v1/adminapp/tenant/featured-groups', [
+            'category_name' => 'Food',
+            'is_featured' => true,
+        ])
+            ->assertCreated()
+            ->assertJsonPath('data.code', 'food')
+            ->assertJsonPath('data.category_name', 'Food')
+            ->assertJsonPath('data.group_name', 'Food')
+            ->assertJsonPath('data.is_featured', true)
+            ->assertJsonPath('data.type', 'category')
+            ->assertJsonPath('data.product_layout', 'row')
+            ->assertJsonPath('data.group_layout', 'paginated');
+
+        $categoryId = $response->json('data.category_id');
+        $this->assertDatabaseHas('categorias', [
+            'id' => $categoryId,
+            'tenant_code' => $tenant->codigo,
+            'nombre' => 'Food',
+        ]);
+        $this->assertDatabaseHas('featured_groups', [
+            'tenant_code' => $tenant->codigo,
+            'code' => 'food',
+            'source_type' => 'category',
+            'category_id' => $categoryId,
+            'product_layout' => 'row',
+            'group_layout' => 'paginated',
+            'group_name' => 'Food',
+        ]);
+    }
+
+    public function test_store_uses_column_with_cart_when_the_category_is_not_featured(): void
+    {
+        $tenant = $this->createTenant('acme');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->postJson('/api/v1/adminapp/tenant/featured-groups', [
+            'category_name' => 'Parking',
+            'is_featured' => false,
+        ])
+            ->assertCreated()
+            ->assertJsonPath('data.is_featured', false)
+            ->assertJsonPath('data.product_layout', 'column_with_cart')
+            ->assertJsonPath('data.group_layout', 'paginated');
+    }
+
+    public function test_update_changes_the_category_and_group_together(): void
+    {
+        $tenant = $this->createTenant('acme');
+        $group = $this->createCategoryGroup($tenant, 'Old name', ProductLayout::ColumnWithCart);
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->putJson("/api/v1/adminapp/tenant/featured-groups/{$group->id}", [
+            'category_name' => 'New name',
+            'is_featured' => true,
+        ])
+            ->assertOk()
+            ->assertJsonPath('data.code', 'old-name')
+            ->assertJsonPath('data.category_name', 'New name')
+            ->assertJsonPath('data.group_name', 'New name')
+            ->assertJsonPath('data.is_featured', true)
+            ->assertJsonPath('data.product_layout', 'row')
+            ->assertJsonPath('data.group_layout', 'paginated');
+
+        $this->assertDatabaseHas('categorias', [
+            'id' => $group->category_id,
+            'nombre' => 'New name',
+        ]);
+        $this->assertDatabaseHas('featured_groups', [
+            'id' => $group->id,
+            'code' => 'old-name',
+            'group_name' => 'New name',
+            'product_layout' => 'row',
+            'group_layout' => 'paginated',
+        ]);
+    }
+
+    public function test_update_rejects_groups_from_another_tenant_or_source(): void
+    {
+        $tenant = $this->createTenant('acme');
+        $otherTenant = $this->createTenant('other');
+        $otherGroup = $this->createCategoryGroup($otherTenant, 'Other');
+        $allGroup = FeaturedGroup::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'source_type' => FeaturedGroupSource::All,
+            'product_layout' => ProductLayout::Row,
+            'group_layout' => GroupLayout::Paginated,
+            'group_name' => 'All products',
+            'group_order' => 0,
+        ]);
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->putJson(
+            "/api/v1/adminapp/tenant/featured-groups/{$otherGroup->id}",
+            $this->payload(),
+        )->assertNotFound();
+        $this->putJson(
+            "/api/v1/adminapp/tenant/featured-groups/{$allGroup->id}",
+            $this->payload(),
+        )->assertNotFound();
+    }
+
+    public function test_name_and_featured_flag_are_required(): void
+    {
+        $tenant = $this->createTenant('acme');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->postJson('/api/v1/adminapp/tenant/featured-groups', [
+            'category_name' => '',
+            'is_featured' => 'yes',
+        ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors(['category_name', 'is_featured']);
+
+        $this->assertDatabaseCount('categorias', 0);
+        $this->assertDatabaseCount('featured_groups', 0);
+    }
+
+    public function test_the_controller_is_not_available_for_non_onticket_tenants(): void
+    {
+        $tenant = $this->createTenant('store', 'shopit');
+        Sanctum::actingAs($this->createAdminAppUser($tenant));
+
+        $this->getJson('/api/v1/adminapp/tenant/featured-groups')->assertNotFound();
+        $this->postJson('/api/v1/adminapp/tenant/featured-groups', $this->payload())
+            ->assertNotFound();
+    }
+
+    public function test_a_customer_cannot_manage_onticket_featured_groups(): void
+    {
+        Sanctum::actingAs(User::factory()->create([
+            'rol_codigo' => RoleCode::User->value,
+            'tenant_codigo' => null,
+        ]));
+
+        $this->getJson('/api/v1/adminapp/tenant/featured-groups')->assertForbidden();
+        $this->postJson('/api/v1/adminapp/tenant/featured-groups', $this->payload())
+            ->assertForbidden();
+    }
+
+    /** @return array{category_name: string, is_featured: bool} */
+    private function payload(): array
+    {
+        return [
+            'category_name' => 'Food',
+            'is_featured' => true,
+        ];
+    }
+
+    private function createTenant(string $code, string $websiteType = 'onticket'): Tenant
+    {
+        return Tenant::query()->create([
+            'codigo' => $code,
+            'nombre' => ucfirst($code),
+            'dominio' => "{$code}.test",
+            'website_type_code' => $websiteType,
+        ]);
+    }
+
+    private function createAdminAppUser(Tenant $tenant): User
+    {
+        return User::factory()->create([
+            'rol_codigo' => RoleCode::AdminApp->value,
+            'tenant_codigo' => $tenant->codigo,
+        ]);
+    }
+
+    private function createCategoryGroup(
+        Tenant $tenant,
+        string $name,
+        ProductLayout $productLayout = ProductLayout::Row,
+        int $order = 0,
+    ): FeaturedGroup {
+        $category = Category::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'nombre' => $name,
+        ]);
+
+        return FeaturedGroup::query()->create([
+            'tenant_code' => $tenant->codigo,
+            'source_type' => FeaturedGroupSource::Category,
+            'category_id' => $category->id,
+            'product_layout' => $productLayout,
+            'group_layout' => GroupLayout::Paginated,
+            'group_name' => $name,
+            'group_order' => $order,
+        ]);
+    }
+}

tests/Feature/Integration/TelepagosWebhookTest.php

@@ -0,0 +1,531 @@
+<?php
+
+namespace Tests\Feature\Integration;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Auth\Models\User;
+use App\Domains\Cart\Models\Cart;
+use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Category;
+use App\Domains\Catalog\Models\Inventory;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Integration\Models\ClientIntegration;
+use App\Domains\Integration\Models\Integration;
+use App\Domains\Purchase\Models\Purchase;
+use App\Domains\Purchase\Models\TelepagosPayment;
+use App\Domains\Purchase\Services\CheckoutService;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Queue;
+use Illuminate\Support\Str;
+use Tests\TestCase;
+
+class TelepagosWebhookTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        config(['services.integrations.secret' => 'base64:'.base64_encode(random_bytes(32))]);
+        Cache::flush();
+        Queue::fake();
+    }
+
+    public function test_transfer_payment_intent_requires_a_valid_transfer_payer_dni(): void
+    {
+        $tenant = $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');
+        $user = User::factory()->create();
+        $variant = $this->createVariantForTenant('sonder', 10, '50.00');
+        $purchase = $this->createPendingTransferPurchase($tenant, $user->id, $variant->id, 1, '12345678');
+
+        $this->actingAs($user, 'sanctum')
+            ->postJson("/api/tenants/sonder/compras/{$purchase->id}/payment-intent", [
+                'method' => 'transfer',
+            ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors(['transfer_payer_dni']);
+
+        $this->actingAs($user, 'sanctum')
+            ->postJson("/api/tenants/sonder/compras/{$purchase->id}/payment-intent", [
+                'method' => 'transfer',
+                'transfer_payer_dni' => '12.345.678',
+            ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors(['transfer_payer_dni']);
+    }
+
+    public function test_transfer_payment_intent_persists_transfer_payer_dni_without_replacing_customer_dni(): void
+    {
+        config()->set('purchase.payment_expiration_minutes.transfer', 60);
+        $now = now()->startOfSecond();
+        $this->travelTo($now);
+
+        $tenant = $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');
+        $this->configureTelepagosIntegration($tenant);
+        $user = User::factory()->create();
+        $variant = $this->createVariantForTenant('sonder', 10, '50.00');
+        $purchase = $this->createPendingTransferPurchase($tenant, $user->id, $variant->id, 1, '12345678');
+        $purchase->update(['status' => Purchase::STATUS_CREATED]);
+
+        Http::fake([
+            'https://api.telepagos.com.ar/v2/auth/token' => Http::response([
+                'status' => 'ok',
+                'token' => 'test-token',
+                'expires_at' => now()->addHour()->toIso8601String(),
+            ]),
+            'https://api.telepagos.com.ar/v2/account/info' => Http::response([
+                'status' => 'ok',
+                'holder' => 'Telepagos Test',
+                'cvu' => '0000003100000000000001',
+                'alias' => 'telepagos.test',
+                'entity' => 'Telepagos S.A.',
+            ]),
+        ]);
+
+        $this->actingAs($user, 'sanctum')
+            ->postJson("/api/tenants/sonder/compras/{$purchase->id}/payment-intent", [
+                'method' => 'transfer',
+                'transfer_payer_dni' => '23456789',
+            ])
+            ->assertOk()
+            ->assertJsonPath('transfer_data.alias', 'telepagos.test');
+
+        $this->assertDatabaseHas('compras', [
+            'id' => $purchase->id,
+            'dni' => '87654321',
+            'transfer_payer_dni' => '23456789',
+            'payment_method' => 'transfer',
+            'status' => Purchase::STATUS_PENDING_PAYMENT,
+        ]);
+        $this->assertDatabaseHas('stock_reservations', [
+            'id' => $purchase->stock_reservation_id,
+            'status' => 'active',
+            'expires_at' => $now->copy()->addMinutes(60)->toDateTimeString(),
+        ]);
+
+        $this->travelBack();
+    }
+
+    public function test_transfer_webhook_matches_pending_purchase_by_dni_and_total_amount(): void
+    {
+        $tenant = $this->createTenant('sonder', 'Sonder', 'sonder.com.ar');
+        $this->configureTelepagosIntegration($tenant);
+
+        $matchingUser = User::factory()->create([
+            'email' => 'buyer@example.com',
+        ]);
+        $newerUser = User::factory()->create([
+            'email' => 'buyer-2@example.com',
+        ]);
+
+        $variant = $this->createVariantForTenant('sonder', 10, '50.00');
+
+        $matchingPurchase = $this->createPendingTransferPurchase(
+            $tenant,
+            $matchingUser->id,
+            $variant->id,
+            1,
+            '12345678'
+        );
+
+        $newerPurchase = $this->createPendingTransferPurchase(
+            $tenant,
+            $newerUser->id,
+            $variant->id,
+            2,
+            '12345678'
+        );
+
+        Http::fake([
+            'https://api.telepagos.com.ar/v2/auth/token' => Http::response([
+                'status' => 'ok',
+                'token' => 'test-token',
+                'expires_at' => now()->addHour()->toIso8601String(),
+            ]),
+            'https://api.telepagos.com.ar/v2/payment/cashin/6351' => Http::response([
+                'status' => 'ok',
+                'data' => [
+                    'amount' => 50,
+                    'operation_id' => 1,
+                    'transaction_id' => 'tx-123',
+                    'buyer' => [
+                        'cuit' => '20123456789',
+                    ],
+                ],
+            ]),
+        ]);
+
+        $this->postJson('/api/webhooks/telepagos/sonder', [
+            'id' => '6351',
+        ])->assertOk()->assertJsonPath('status', 'success');
+
+        $this->assertDatabaseHas('compras', [
+            'id' => $matchingPurchase->id,
+            'status' => Purchase::STATUS_PAID,
+            'payment_method' => 'transfer',
+            'total' => 50,
+        ]);
+
+        $this->assertDatabaseHas('compras', [
+            'id' => $newerPurchase->id,
+            'status' => Purchase::STATUS_PENDING_PAYMENT,
+            'payment_method' => 'transfer',
+            'total' => 100,
+        ]);
+
+        $this->assertDatabaseHas('telepagos_payments', [
+            'compra_id' => $matchingPurchase->id,
+            'amount' => 50,
+            'operation_id' => 1,
+            'transaction_id' => 'tx-123',
+        ]);
+
+        $this->assertDatabaseMissing('telepagos_payments', [
+            'compra_id' => $newerPurchase->id,
+        ]);
+
+        $this->assertDatabaseHas('compra_items', [
+            'compra_id' => $matchingPurchase->id,
+            'source_catalog_item_id' => $variant->catalog_item_id,
+            'source_variant_id' => $variant->id,
+            'cantidad' => 1,
+            'total' => 50,
+        ]);
+
+        $this->assertDatabaseHas('inventories', [
+            'id' => $variant->inventory_id,
+            'real_stock' => 9,
+            'reserved_stock' => 2,
+            'sold_units' => 1,
+        ]);
+
+        $this->assertDatabaseHas('compra_items', [
+            'compra_id' => $newerPurchase->id,
+            'cantidad' => 2,
+        ]);
+        $newerReservationId = $newerPurchase->fresh()->stock_reservation_id;
+        $this->assertNotNull($newerReservationId);
+        $this->assertDatabaseHas('stock_reservations', [
+            'id' => $newerReservationId,
+            'status' => 'active',
+        ]);
+        $this->assertDatabaseHas('stock_reservation_lines', [
+            'stock_reservation_id' => $newerReservationId,
+            'inventory_id' => $variant->inventory_id,
+            'quantity' => 2,
+        ]);
+
+        $this->assertSoftDeleted('carritos', [
+            'id' => $matchingPurchase->cart_id,
+        ]);
+    }
+
+    public function test_transfer_webhook_buys_unlimited_inventory_without_reducing_real_stock(): void
+    {
+        $tenant = $this->createTenant('unlimited', 'Unlimited', 'unlimited.com.ar');
+        $this->configureTelepagosIntegration($tenant);
+        $user = User::factory()->create();
+        $variant = $this->createVariantForTenant(
+            'unlimited',
+            0,
+            '50.00',
+            'service',
+            InventoryPolicy::Unlimited,
+        );
+        $purchase = $this->createPendingTransferPurchase(
+            $tenant,
+            $user->id,
+            $variant->id,
+            3,
+            '87654321',
+        );
+
+        Http::fake([
+            'https://api.telepagos.com.ar/v2/auth/token' => Http::response([
+                'status' => 'ok',
+                'token' => 'test-token',
+                'expires_at' => now()->addHour()->toIso8601String(),
+            ]),
+            'https://api.telepagos.com.ar/v2/payment/cashin/7000' => Http::response([
+                'status' => 'ok',
+                'data' => [
+                    'amount' => 150,
+                    'operation_id' => 1,
+                    'transaction_id' => 'tx-unlimited',
+                    'buyer' => ['cuit' => '20876543219'],
+                ],
+            ]),
+        ]);
+
+        $this->postJson('/api/webhooks/telepagos/unlimited', ['id' => '7000'])
+            ->assertOk()
+            ->assertJsonPath('status', 'success');
+
+        $this->assertDatabaseHas('compras', [
+            'id' => $purchase->id,
+            'status' => Purchase::STATUS_PAID,
+        ]);
+        $this->assertDatabaseHas('inventories', [
+            'id' => $variant->inventory_id,
+            'real_stock' => 0,
+            'reserved_stock' => 0,
+            'sold_units' => 3,
+        ]);
+    }
+
+    public function test_transfer_webhook_records_unmatched_payment_when_multiple_purchases_match(): void
+    {
+        $tenant = $this->createTenant('ambiguous', 'Ambiguous', 'ambiguous.com.ar');
+        $this->configureTelepagosIntegration($tenant);
+
+        $variant = $this->createVariantForTenant('ambiguous', 10, '50.00');
+        $firstPurchase = $this->createPendingTransferPurchase(
+            $tenant,
+            User::factory()->create()->id,
+            $variant->id,
+            1,
+            '12345678',
+        );
+        $secondPurchase = $this->createPendingTransferPurchase(
+            $tenant,
+            User::factory()->create()->id,
+            $variant->id,
+            1,
+            '12345678',
+        );
+        $thirdPurchase = $this->createPendingTransferPurchase(
+            $tenant,
+            User::factory()->create()->id,
+            $variant->id,
+            1,
+            '12345678',
+        );
+
+        Http::fake([
+            'https://api.telepagos.com.ar/v2/auth/token' => Http::response([
+                'status' => 'ok',
+                'token' => 'test-token',
+                'expires_at' => now()->addHour()->toIso8601String(),
+            ]),
+            'https://api.telepagos.com.ar/v2/payment/cashin/ambiguous' => Http::response([
+                'status' => 'ok',
+                'data' => [
+                    'amount' => 50,
+                    'operation_id' => 1,
+                    'transaction_id' => 'tx-ambiguous',
+                    'buyer' => [
+                        'cuit' => '20123456789',
+                    ],
+                ],
+            ]),
+        ]);
+
+        $this->postJson('/api/webhooks/telepagos/ambiguous', [
+            'id' => 'ambiguous',
+        ])->assertOk()->assertJsonPath('status', 'success');
+
+        $this->assertDatabaseHas('telepagos_payments', [
+            'compra_id' => null,
+            'amount' => 50,
+            'operation_id' => 1,
+            'transaction_id' => 'tx-ambiguous',
+        ]);
+        $payment = TelepagosPayment::query()
+            ->where('transaction_id', 'tx-ambiguous')
+            ->firstOrFail();
+        $this->assertEqualsCanonicalizing(
+            [$firstPurchase->id, $secondPurchase->id, $thirdPurchase->id],
+            $payment->matched_purchase_ids,
+        );
+        $this->assertDatabaseHas('compras', [
+            'id' => $firstPurchase->id,
+            'status' => Purchase::STATUS_PENDING_PAYMENT,
+        ]);
+        $this->assertDatabaseHas('compras', [
+            'id' => $secondPurchase->id,
+            'status' => Purchase::STATUS_PENDING_PAYMENT,
+        ]);
+        $this->assertDatabaseHas('compras', [
+            'id' => $thirdPurchase->id,
+            'status' => Purchase::STATUS_PENDING_PAYMENT,
+        ]);
+    }
+
+    public function test_webhook_confirms_a_purchase_with_tickets_enabled(): void
+    {
+        $tenant = $this->createTenant('expired-ticket', 'Expired Ticket', 'expired-ticket.com.ar');
+        $this->configureTelepagosIntegration($tenant);
+        $user = User::factory()->create();
+        $variant = $this->createVariantForTenant('expired-ticket', 1, '50.00');
+        $variant->catalogItem->update([
+            'has_tickets' => true,
+        ]);
+        $purchase = $this->createPendingTransferPurchase(
+            $tenant,
+            $user->id,
+            $variant->id,
+            1,
+            '87654321',
+        );
+
+        Http::fake([
+            'https://api.telepagos.com.ar/v2/auth/token' => Http::response([
+                'status' => 'ok',
+                'token' => 'test-token',
+                'expires_at' => now()->addHour()->toIso8601String(),
+            ]),
+            'https://api.telepagos.com.ar/v2/payment/cashin/7001' => Http::response([
+                'status' => 'ok',
+                'data' => [
+                    'amount' => 50,
+                    'operation_id' => 1,
+                    'transaction_id' => 'tx-expired-ticket',
+                    'buyer' => ['cuit' => '20876543219'],
+                ],
+            ]),
+        ]);
+
+        $this->postJson('/api/webhooks/telepagos/expired-ticket', ['id' => '7001'])
+            ->assertOk()
+            ->assertJsonPath('status', 'success');
+
+        $this->assertDatabaseHas('compras', [
+            'id' => $purchase->id,
+            'status' => Purchase::STATUS_PAID,
+        ]);
+        $this->assertDatabaseHas('tickets', [
+            'source_catalog_item_id' => $variant->catalog_item_id,
+            'source_variant_id' => $variant->id,
+            'user_id' => $user->id,
+        ]);
+    }
+
+    private function createPendingTransferPurchase(
+        Tenant $tenant,
+        int $userId,
+        int $variantId,
+        int $quantity,
+        string $dni,
+    ): Purchase {
+        $cart = Cart::query()->create([
+            'tenant_codigo' => $tenant->codigo,
+            'user_id' => $userId,
+            'status' => 'active',
+        ]);
+
+        $variant = Variant::query()->findOrFail($variantId);
+        $cart->addItem($variant->catalog_item_id, $variant->id, $quantity);
+
+        /** @var CheckoutService $checkoutService */
+        $checkoutService = app(CheckoutService::class);
+
+        $purchase = $checkoutService->startCheckout($tenant, $userId, [
+            'cart_id' => $cart->id,
+            'dni' => '87654321',
+            'telefono' => '+54 9 341 555-4321',
+            'nombre_apellido' => 'Juan Perez',
+            'email' => 'juan.perez@example.com',
+        ]);
+
+        $purchase->update([
+            'payment_method' => 'transfer',
+            'transfer_payer_dni' => $dni,
+        ]);
+
+        $checkoutService->completePurchase($purchase);
+
+        return $purchase->fresh();
+    }
+
+    private function configureTelepagosIntegration(Tenant $tenant): void
+    {
+        Integration::create([
+            'integration_code' => 'telepagos_homo',
+            'name' => 'Telepagos',
+            'url' => 'https://api.telepagos.com.ar',
+            'integration_data_schema' => [
+                'username' => 'required|string',
+                'password' => 'required|string',
+            ],
+        ]);
+
+        ClientIntegration::create([
+            'client_id' => $tenant->client_id,
+            'integration_code' => 'telepagos_homo',
+            'integration_data' => [
+                'username' => 'user123',
+                'password' => 'pass123',
+            ],
+        ]);
+    }
+
+    private function createVariantForTenant(
+        string $tenantCode,
+        int $stock,
+        string $price,
+        string $slugPrefix = 'shirt',
+        InventoryPolicy $inventoryPolicy = InventoryPolicy::Tracked,
+    ): Variant {
+        $category = Category::query()->create([
+            'tenant_code' => $tenantCode,
+            'nombre' => "{$slugPrefix} category {$tenantCode}",
+        ]);
+
+        $inventory = Inventory::query()->create(['real_stock' => $stock]);
+        $catalogItem = CatalogItem::query()->create([
+            'tenant_code' => $tenantCode,
+            'category_id' => $category->id,
+            'slug' => "{$slugPrefix}-{$tenantCode}-".CatalogItem::query()->count(),
+            'nombre' => ucfirst($slugPrefix)." {$tenantCode}",
+            'descripcion' => 'Test product',
+            'precio' => $price,
+            'inventory_policy' => $inventoryPolicy,
+        ]);
+
+        return Variant::query()->create([
+            'catalog_item_id' => $catalogItem->id,
+            'inventory_id' => $inventory->id,
+        ])->load(['catalogItem', 'inventory']);
+    }
+
+    private function createTenant(string $codigo, string $nombre, string $dominio): Tenant
+    {
+        $hdrKey = (string) Str::uuid();
+        $ftrKey = (string) Str::uuid();
+
+        $headerAttachment = Attachment::create([
+            'key' => $hdrKey,
+            'path' => 'tenants/'.$hdrKey.'.png',
+            'filename' => 'logo_header.png',
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+        $footerAttachment = Attachment::create([
+            'key' => $ftrKey,
+            'path' => 'tenants/'.$ftrKey.'.png',
+            'filename' => 'logo_footer.png',
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+
+        return Tenant::create([
+            'codigo' => $codigo,
+            'nombre' => $nombre,
+            'dominio' => $dominio,
+            'primary_color' => '#111111',
+            'secondary_color' => '#222222',
+            'danger_color' => '#333333',
+            'success_color' => '#28a745',
+            'header_bg_color' => '#444444',
+            'footer_bg_color' => '#444444',
+            'header_logo_id' => $headerAttachment->id,
+            'footer_logo_id' => $footerAttachment->id,
+        ]);
+    }
+}

tests/Feature/MailTest/MailTestControllerTest.php

@@ -0,0 +1,189 @@
+<?php
+
+namespace Tests\Feature\MailTest;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Integration\Models\ClientIntegration;
+use App\Domains\Integration\Models\Integration;
+use App\Domains\MailTest\Mailables\TestMail;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Mail\Mailable;
+use Illuminate\Support\Facades\Mail;
+use Tests\TestCase;
+
+class MailTestControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_it_sends_a_test_email(): void
+    {
+        Mail::fake();
+        $tenant = $this->createTenant();
+
+        $response = $this->postJson('/api/acme/mail-test/send', [
+            'to' => 'recipient@example.com',
+            'subject' => 'SMTP test',
+            'message' => 'Test message',
+        ]);
+
+        $response->assertOk()
+            ->assertJsonPath('message', 'Correo de prueba enviado correctamente.')
+            ->assertJsonPath('recipient', 'recipient@example.com')
+            ->assertJsonPath('tenant_code', 'acme')
+            ->assertJsonPath('mailer', 'tenant-smtp')
+            ->assertJsonStructure(['sent_at']);
+
+        Mail::assertSent(Mailable::class, function (Mailable $mail) use ($tenant): bool {
+            return $mail->hasTo('recipient@example.com')
+                && $mail->subject === 'SMTP test'
+                && str_contains($mail->render(), 'Test message')
+                && str_contains($mail->render(), $tenant->nombre);
+        });
+    }
+
+    public function test_it_uses_default_content_when_optional_fields_are_omitted(): void
+    {
+        Mail::fake();
+        $this->createTenant();
+
+        $this->postJson('/api/acme/mail-test/send', [
+            'to' => 'recipient@example.com',
+        ])->assertOk();
+
+        Mail::assertSent(Mailable::class, function (Mailable $mail): bool {
+            return $mail->subject === 'Prueba de correo de Shopit'
+                && str_contains($mail->render(), 'Este es un correo de prueba enviado desde Shopit.');
+        });
+    }
+
+    public function test_it_validates_the_recipient(): void
+    {
+        Mail::fake();
+        $this->createTenant();
+
+        $this->postJson('/api/acme/mail-test/send', [
+            'to' => 'invalid-email',
+        ])->assertUnprocessable()
+            ->assertJsonValidationErrors(['to']);
+
+        Mail::assertNothingSent();
+    }
+
+    public function test_the_mail_template_uses_the_tenant_branding(): void
+    {
+        $tenant = new Tenant([
+            'codigo' => 'tenant-store',
+            'nombre' => 'Tenant Store',
+            'primary_color' => '#778899',
+            'header_bg_color' => '#112233',
+            'footer_bg_color' => '#445566',
+        ]);
+
+        $tenant->setRelation('headerLogo', new class extends Attachment
+        {
+            public function getTemporaryUrl(int $expiresInMinutes = 10): string
+            {
+                return 'https://example.com/header-logo.png';
+            }
+        });
+        $tenant->setRelation('footerLogo', new class extends Attachment
+        {
+            public function getTemporaryUrl(int $expiresInMinutes = 10): string
+            {
+                return 'https://example.com/footer-logo.png';
+            }
+        });
+
+        $mail = new TestMail(
+            'Branded email',
+            'Tenant message',
+            $tenant,
+        );
+
+        $html = $mail->render();
+
+        $this->assertStringContainsString('https://example.com/header-logo.png', $html);
+        $this->assertStringContainsString('https://example.com/footer-logo.png', $html);
+        $this->assertStringContainsString('background-color: #112233', $html);
+        $this->assertStringContainsString('background-color: #445566', $html);
+        $this->assertStringContainsString('color: #778899', $html);
+        $this->assertStringContainsString('Tenant Store', $html);
+        $this->assertStringContainsString('Tenant message', $html);
+    }
+
+    public function test_it_returns_not_found_for_an_unknown_tenant(): void
+    {
+        Mail::fake();
+
+        $this->postJson('/api/unknown/mail-test/send', [
+            'to' => 'recipient@example.com',
+        ])->assertNotFound();
+
+        Mail::assertNothingSent();
+    }
+
+    public function test_it_does_not_resolve_the_tenant_by_id(): void
+    {
+        Mail::fake();
+        $tenant = $this->createTenant();
+
+        $this->postJson("/api/{$tenant->id}/mail-test/send", [
+            'to' => 'recipient@example.com',
+        ])->assertNotFound();
+
+        Mail::assertNothingSent();
+    }
+
+    private function createTenant(): Tenant
+    {
+        $headerLogo = Attachment::create([
+            'path' => 'tenants/header.png',
+            'filename' => 'header.png',
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+            'extension' => 'png',
+        ]);
+        $footerLogo = Attachment::create([
+            'path' => 'tenants/footer.png',
+            'filename' => 'footer.png',
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+            'extension' => 'png',
+        ]);
+
+        $tenant = Tenant::create([
+            'codigo' => 'acme',
+            'nombre' => 'Acme Store',
+            'dominio' => 'acme.example.com',
+            'primary_color' => '#778899',
+            'secondary_color' => '#64748b',
+            'danger_color' => '#dc2626',
+            'success_color' => '#16a34a',
+            'header_bg_color' => '#112233',
+            'footer_bg_color' => '#445566',
+            'header_logo_id' => $headerLogo->id,
+            'footer_logo_id' => $footerLogo->id,
+        ]);
+
+        Integration::create([
+            'integration_code' => 'email',
+            'name' => 'Email',
+        ]);
+        ClientIntegration::create([
+            'client_id' => $tenant->client_id,
+            'integration_code' => 'email',
+            'integration_data' => [
+                'MAIL_SCHEME' => 'smtp',
+                'MAIL_HOST' => 'smtp.example.com',
+                'MAIL_PORT' => 587,
+                'MAIL_USERNAME' => 'mailer@example.com',
+                'MAIL_PASSWORD' => 'secret',
+                'MAIL_FROM_ADDRESS' => 'store@example.com',
+            ],
+        ]);
+
+        return $tenant;
+    }
+}

tests/Feature/Menu/TenantMenuControllerTest.php

@@ -0,0 +1,171 @@
+<?php
+
+namespace Tests\Feature\Menu;
+
+use App\Domains\Attachable\Enums\AttachmentType;
+use App\Domains\Attachable\Models\Attachment;
+use App\Domains\Menu\Models\Menu;
+use App\Domains\Tenant\Models\Tenant;
+use Database\Seeders\MenuSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class TenantMenuControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_it_validates_static_content_with_the_menu_schema(): void
+    {
+        $tenant = $this->createTenant();
+        $menu = Menu::query()->create([
+            'code' => 'about',
+            'label' => 'Nosotros',
+            'content_type' => Menu::CONTENT_TYPE_STATIC,
+            'static_content_schema' => [
+                'title' => 'required|string|max:20',
+                'sections' => 'required|array|min:1',
+                'sections.*.body' => 'required|string',
+            ],
+            'route' => '/about',
+        ]);
+
+        $this->postJson("/api/{$tenant->codigo}/menues/{$menu->code}", [
+            'static_content' => [
+                'title' => 123,
+                'sections' => [],
+            ],
+        ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors([
+                'static_content.title',
+                'static_content.sections',
+            ]);
+
+        $this->assertDatabaseMissing('tenants_menues', [
+            'tenant_code' => $tenant->codigo,
+            'menu_code' => $menu->code,
+        ]);
+    }
+
+    public function test_it_configures_a_static_menu_when_content_matches_the_schema(): void
+    {
+        $tenant = $this->createTenant();
+        $menu = Menu::query()->create([
+            'code' => 'about',
+            'label' => 'Nosotros',
+            'content_type' => Menu::CONTENT_TYPE_STATIC,
+            'static_content_schema' => [
+                'title' => 'required|string|max:20',
+                'sections' => 'required|array|min:1',
+                'sections.*.body' => 'required|string',
+            ],
+            'route' => '/about',
+        ]);
+
+        $content = [
+            'title' => 'Nosotros',
+            'sections' => [
+                ['body' => 'Nuestra historia'],
+            ],
+        ];
+
+        $this->postJson("/api/{$tenant->codigo}/menues/{$menu->code}", [
+            'static_content' => $content,
+        ])
+            ->assertOk()
+            ->assertJsonPath('static_content.title', 'Nosotros')
+            ->assertJsonPath('static_content.sections.0.body', 'Nuestra historia');
+
+        $this->assertSame(
+            $content,
+            $tenant->menues()->where('menues.code', $menu->code)->firstOrFail()->pivot->static_content
+        );
+    }
+
+    public function test_dynamic_menus_do_not_require_static_content(): void
+    {
+        $tenant = $this->createTenant();
+        $menu = Menu::query()->create([
+            'code' => 'catalog',
+            'label' => 'Catálogo',
+            'route' => '/catalog',
+        ]);
+
+        $this->postJson("/api/{$tenant->codigo}/menues/{$menu->code}")
+            ->assertOk()
+            ->assertJsonPath('static_content', null);
+
+        $this->assertDatabaseHas('tenants_menues', [
+            'tenant_code' => $tenant->codigo,
+            'menu_code' => $menu->code,
+            'static_content' => null,
+        ]);
+    }
+
+    public function test_contact_content_requires_coordinates_inside_each_address(): void
+    {
+        $tenant = $this->createTenant();
+        $this->seed(MenuSeeder::class);
+
+        $this->postJson("/api/{$tenant->codigo}/menues/help.contact", [
+            'static_content' => [
+                'whatsapp' => [
+                    'whatsapp_url' => 'https://wa.me/543412602222',
+                    'whatsapp_label' => 'Chatea con nosotros',
+                ],
+                'phone' => '+54 9 (0341) 6658247',
+                'locations' => [
+                    'rosario' => [
+                        'label' => 'Rosario',
+                        'addresses' => [
+                            [
+                                'label' => 'Av. San Lorenzo 1542',
+                                'address' => 'Av. San Lorenzo 1542, Rosario',
+                                'coordinates' => [-91, -181],
+                            ],
+                        ],
+                    ],
+                ],
+                'map_locations' => [
+                    'legacy_point' => [-32.946820, -60.639320],
+                ],
+            ],
+        ])
+            ->assertUnprocessable()
+            ->assertJsonValidationErrors([
+                'static_content.locations.rosario.addresses.0.coordinates.0',
+                'static_content.locations.rosario.addresses.0.coordinates.1',
+                'static_content.map_locations',
+            ]);
+    }
+
+    private function createTenant(): Tenant
+    {
+        $headerLogo = $this->createAttachment('header.png');
+        $footerLogo = $this->createAttachment('footer.png');
+
+        return Tenant::query()->create([
+            'codigo' => 'acme',
+            'nombre' => 'Acme',
+            'dominio' => 'acme.com',
+            'primary_color' => '#111111',
+            'secondary_color' => '#222222',
+            'danger_color' => '#333333',
+            'success_color' => '#444444',
+            'header_bg_color' => '#ffffff',
+            'footer_bg_color' => '#ffffff',
+            'header_logo_id' => $headerLogo->id,
+            'footer_logo_id' => $footerLogo->id,
+        ]);
+    }
+
+    private function createAttachment(string $filename): Attachment
+    {
+        return Attachment::query()->create([
+            'path' => "test/{$filename}",
+            'filename' => $filename,
+            'type' => AttachmentType::Image,
+            'mime_type' => 'image/png',
+        ]);
+    }
+}

tests/Feature/Migrations/SetWebsiteTypeFaviconTest.php

@@ -1,61 +0,0 @@
-<?php
-
-namespace Tests\Feature\Migrations;
-
-use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Facades\DB;
-use Illuminate\Support\Facades\Storage;
-use Tests\TestCase;
-
-class SetWebsiteTypeFaviconTest extends TestCase
-{
-    use RefreshDatabase;
-
-    public function test_it_uploads_one_favicon_and_shares_the_attachment_between_website_types(): void
-    {
-        Storage::fake('s3');
-
-        DB::table('website_type')->insert([
-            [
-                'codigo' => 'shopit',
-                'nombre' => 'ShopIt',
-                'created_at' => now(),
-                'updated_at' => now(),
-            ],
-            [
-                'codigo' => 'onticket',
-                'nombre' => 'OnTicket',
-                'created_at' => now(),
-                'updated_at' => now(),
-            ],
-        ]);
-
-        $migration = require database_path(
-            'migrations/2026_08_26_000000_set_website_type_favicon.php'
-        );
-
-        $migration->up();
-        $migration->up();
-
-        $faviconIds = DB::table('website_type')
-            ->whereIn('codigo', ['shopit', 'onticket'])
-            ->pluck('favicon_id');
-
-        $this->assertCount(2, $faviconIds);
-        $this->assertNotNull($faviconIds->first());
-        $this->assertSame(1, $faviconIds->unique()->count());
-
-        $attachment = DB::table('attachments')->where('id', $faviconIds->first())->first();
-
-        $this->assertNotNull($attachment);
-        $this->assertSame('onticket_favicon.svg', $attachment->filename);
-        $this->assertSame('image/svg+xml', $attachment->mime_type);
-        $this->assertSame('svg', $attachment->extension);
-        $this->assertSame(1, DB::table('attachments')->where('filename', 'onticket_favicon.svg')->count());
-        Storage::disk('s3')->assertExists($attachment->path);
-        $this->assertSame(
-            file_get_contents(public_path('images/website_types/onticket_favicon.svg')),
-            Storage::disk('s3')->get($attachment->path),
-        );
-    }
-}

tests/Feature/Notification/NotificationMailServiceTest.php

@@ -142,7 +142,7 @@ class NotificationMailServiceTest extends TestCase
         });
     }
 
-    public function test_it_sends_one_purchase_confirmation_with_generated_tickets_attached(): void
+    public function test_it_sends_purchase_and_ticket_emails_to_the_purchase_recipient(): void
     {
         $this->useWebsiteTypeBranding();
         $purchase = Purchase::query()->create([
@@ -175,23 +175,30 @@ class NotificationMailServiceTest extends TestCase
         $ticket = Ticket::query()->create([
             'tenant_code' => $this->tenant->codigo,
             'ticket' => fake()->uuid(),
-            'source_purchase_id' => $purchase->id,
             'source_catalog_item_id' => $catalogItem->id,
             'user_id' => $this->user->id,
         ]);
         $service = app(NotificationMailService::class);
 
-        $service->sendPurchaseConfirmed($purchase->id);
+        $service->sendPurchasePaid($purchase->id);
+        $service->sendTicketsAvailable($purchase->id, [$ticket->id]);
 
-        Mail::assertSent(Mailable::class, 1);
-        Mail::assertSent(Mailable::class, function (Mailable $mail) use ($purchase, $ticket): bool {
+        Mail::assertSent(Mailable::class, 2);
+        Mail::assertSent(Mailable::class, function (Mailable $mail) use ($purchase): bool {
+            $mail->assertTo('checkout@example.com');
+
+            return $mail->subject === "Pago confirmado - Compra #{$purchase->id}"
+                && str_contains($mail->render(), 'Total pagado')
+                && str_contains($mail->render(), 'border-top: 4px solid #112233')
+                && ! str_contains($mail->render(), 'border-top: 4px solid #ff7006');
+        });
+        Mail::assertSent(Mailable::class, function (Mailable $mail) use ($ticket): bool {
             $mail->assertTo('checkout@example.com');
             $attachment = collect($mail->rawAttachments)->firstWhere('name', "tickets_{$ticket->id}.pdf");
 
-            return $mail->subject === "Compra confirmada - Compra #{$purchase->id}"
-                && str_contains($mail->render(), '¡Compra realizada con éxito!')
-                && str_contains($mail->render(), 'Total pagado')
-                && str_contains($mail->render(), 'Tus tickets ya están disponibles')
+            return $mail->subject === 'Tus tickets ya están disponibles'
+                && str_contains($mail->render(), 'Entrada general')
+                && str_contains($mail->render(), 'El ticket está adjunto')
                 && $attachment !== null
                 && $attachment['options'] === ['mime' => 'application/pdf']
                 && str_starts_with($attachment['data'], '%PDF-')
@@ -200,26 +207,6 @@ class NotificationMailServiceTest extends TestCase
         });
     }
 
-    public function test_purchase_confirmation_omits_ticket_content_and_attachment_without_tickets(): void
-    {
-        $purchase = Purchase::query()->create([
-            'tenant_codigo' => $this->tenant->codigo,
-            'user_id' => $this->user->id,
-            'status' => Purchase::STATUS_PAID,
-            'payment_method' => 'transfer',
-            'total' => 25,
-        ]);
-
-        app(NotificationMailService::class)->sendPurchaseConfirmed($purchase->id);
-
-        Mail::assertSent(Mailable::class, function (Mailable $mail) use ($purchase): bool {
-            return $mail->subject === "Compra confirmada - Compra #{$purchase->id}"
-                && str_contains($mail->render(), '¡Compra realizada con éxito!')
-                && ! str_contains($mail->render(), 'Tus tickets ya están disponibles')
-                && $mail->rawAttachments === [];
-        });
-    }
-
     private function useWebsiteTypeBranding(): void
     {
         $websiteType = WebsiteType::query()->create([