feat(purchase,sale,ticket): expose refunded total summary in admin sales and tickets

Documenta la prioridad cliente a tipo de sitio, la edicion compartida, los permisos y los contratos de la API. Aclara la migracion del requisito de configuracion y la asociacion directa requerida por el webhook de Telepagos.

.env.example

@@ -5,6 +5,10 @@ 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
+PURCHASE_TRANSFER_CANDIDATE_AMOUNT_TOLERANCE_PERCENTAGE=5
 STOCK_RESERVATION_EXPIRATION_MINUTES=30
 FRONTEND_URLS=http://localhost:4200
 

app/Domains/Administrator/Controllers/AdminAppAdministratorController.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Domains\Administrator\Controllers;
+
+use App\Domains\Administrator\Requests\StoreAdministratorRequest;
+use App\Domains\Administrator\Requests\UpdateAdministratorRequest;
+use App\Domains\Administrator\Resources\AdministratorResource;
+use App\Domains\Administrator\Services\AdministratorService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use Symfony\Component\HttpFoundation\Response;
+
+class AdminAppAdministratorController extends Controller
+{
+    public function __construct(private readonly AdministratorService $administratorService) {}
+
+    public function index(Request $request): AnonymousResourceCollection
+    {
+        return AdministratorResource::collection($this->administratorService->list(
+            $request->user()->tenant()->firstOrFail(),
+            $request->string('search')->trim()->toString() ?: null,
+        ));
+    }
+
+    public function store(StoreAdministratorRequest $request): AdministratorResource
+    {
+        return AdministratorResource::make($this->administratorService->create(
+            $request->user()->tenant()->firstOrFail(),
+            $request->validated(),
+        ));
+    }
+
+    public function update(UpdateAdministratorRequest $request, int $administrator): AdministratorResource
+    {
+        return AdministratorResource::make($this->administratorService->update(
+            $request->user()->tenant()->firstOrFail(),
+            $administrator,
+            $request->validated(),
+        ));
+    }
+
+    public function destroy(Request $request, int $administrator): Response
+    {
+        $this->administratorService->delete($request->user()->tenant()->firstOrFail(), $administrator, $request->user());
+
+        return response()->noContent();
+    }
+}

app/Domains/Administrator/Requests/StoreAdministratorRequest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domains\Administrator\Requests;
+
+use App\Domains\Authorization\Enums\RoleCode;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class StoreAdministratorRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()?->rol_codigo === RoleCode::AdminApp->value;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+
+        return [
+            'nombre_apellido' => ['required', 'string', 'max:255'],
+            'dni' => ['required', 'string', 'max:50'],
+            'email' => [
+                'required',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::AdminApp->value)->whereNull('deleted_at'),
+            ],
+        ];
+    }
+}

app/Domains/Administrator/Requests/UpdateAdministratorRequest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Domains\Administrator\Requests;
+
+use App\Domains\Authorization\Enums\RoleCode;
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+
+class UpdateAdministratorRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return $this->user()?->rol_codigo === RoleCode::AdminApp->value;
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        $administratorId = (int) $this->route('administrator');
+
+        return [
+            'nombre_apellido' => ['required', 'string', 'max:255'],
+            'dni' => ['required', 'string', 'max:50'],
+            'email' => [
+                'required',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::AdminApp->value)
+                    ->whereNull('deleted_at')
+                    ->ignore($administratorId),
+            ],
+        ];
+    }
+}

app/Domains/Administrator/Resources/AdministratorResource.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Domains\Administrator\Resources;
+
+use App\Domains\Auth\Models\User;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin User */
+class AdministratorResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'nombre_apellido' => $this->nombre_apellido,
+            'dni' => $this->dni,
+            'email' => $this->email,
+            'rol_codigo' => $this->rol_codigo,
+            'role' => $this->whenLoaded('role', fn () => [
+                'codigo' => $this->role?->codigo,
+                'nombre' => $this->role?->nombre,
+            ]),
+        ];
+    }
+}

app/Domains/Administrator/Services/AdministratorService.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Domains\Administrator\Services;
+
+use App\Domains\Auth\Models\ResetPasswordAttempt;
+use App\Domains\Auth\Models\User;
+use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
+use App\Domains\Tenant\Models\Tenant;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Str;
+use Illuminate\Validation\ValidationException;
+
+class AdministratorService
+{
+    public function __construct(private readonly ResetPasswordAttemptService $resetPasswordAttemptService) {}
+
+    /** @return Collection<int, User> */
+    public function list(Tenant $tenant, ?string $search = null): Collection
+    {
+        return $this->query($tenant)->with('role')
+            ->when($search, fn (Builder $query, string $search) => $query->where(function (Builder $query) use ($search): void {
+                $query->where('nombre_apellido', 'like', "%{$search}%")
+                    ->orWhere('dni', 'like', "%{$search}%")
+                    ->orWhere('email', 'like', "%{$search}%");
+            }))
+            ->orderBy('nombre_apellido')->get();
+    }
+
+    /** @param array<string, mixed> $data */
+    public function create(Tenant $tenant, array $data): User
+    {
+        return DB::transaction(function () use ($tenant, $data): User {
+            $administrator = User::query()->create([
+                ...$this->attributes($data),
+                'password' => Str::random(64),
+                'rol_codigo' => RoleCode::AdminApp->value,
+                'tenant_codigo' => $tenant->codigo,
+            ]);
+            $this->resetPasswordAttemptService->createForAdminAppEmail(
+                $administrator->email,
+                ResetPasswordAttempt::REASON_ADMINISTRATOR_CREATED,
+            );
+
+            return $administrator->load('role');
+        });
+    }
+
+    /** @param array<string, mixed> $data */
+    public function update(Tenant $tenant, int $administratorId, array $data): User
+    {
+        return DB::transaction(function () use ($tenant, $administratorId, $data): User {
+            $administrator = $this->query($tenant)->lockForUpdate()->findOrFail($administratorId);
+            $administrator->update($this->attributes($data));
+
+            return $administrator->load('role');
+        });
+    }
+
+    public function delete(Tenant $tenant, int $administratorId, User $actor): void
+    {
+        DB::transaction(function () use ($tenant, $administratorId, $actor): void {
+            // Serialize deletions for this tenant, including requests already authenticated
+            // when another administrator removes their account.
+            Tenant::query()->whereKey($tenant->getKey())->lockForUpdate()->firstOrFail();
+            $administrator = $this->query($tenant)->lockForUpdate()->findOrFail($administratorId);
+            if ($administrator->is($actor)) {
+                throw ValidationException::withMessages(['administrator' => 'No podés eliminar tu propio usuario.']);
+            }
+            $activeAdministrators = $this->query($tenant)->lockForUpdate()->get();
+            if ($activeAdministrators->count() <= 1) {
+                throw ValidationException::withMessages(['administrator' => 'El tenant debe conservar al menos un administrador.']);
+            }
+            abort_unless($activeAdministrators->contains('id', $actor->id), 403);
+            $administrator->tokens()->delete();
+            $administrator->delete();
+        });
+    }
+
+    private function query(Tenant $tenant): Builder
+    {
+        return User::query()->where('tenant_codigo', $tenant->codigo)
+            ->where('rol_codigo', RoleCode::AdminApp->value);
+    }
+
+    /** @param array<string, mixed> $data
+     * @return array<string, mixed>
+     */
+    private function attributes(array $data): array
+    {
+        return [
+            ...Arr::only($data, ['nombre_apellido', 'dni']),
+            'email' => mb_strtolower(trim((string) $data['email'])),
+        ];
+    }
+}

app/Domains/Administrator/documentacion/README.md

@@ -0,0 +1,63 @@
+# Administradores de AdminApp
+
+CRUD de usuarios con rol `adminapp`, limitado al tenant del usuario autenticado.
+Todos los administradores del tenant pueden gestionar esta sección.
+
+## Endpoints
+
+Base: `/api/v1/adminapp/tenant/administrators`.
+Requieren `auth:sanctum` y `adminapp.tenant`.
+
+- `GET /`: listado ordenado por nombre; acepta `search` por nombre, DNI o email.
+- `POST /`: alta; responde `201` con `data`.
+- `PUT /{administrator}`: actualización de los tres campos; responde `200` con `data`.
+- `DELETE /{administrator}`: baja lógica; responde `204`.
+
+Alta y actualización reciben:
+
+```json
+{
+  "nombre_apellido": "Ada Lovelace",
+  "dni": "12345678",
+  "email": "ada@example.test"
+}
+```
+
+Nombre (hasta 255 caracteres), DNI (hasta 50) y email (hasta 255) son obligatorios.
+El email se normaliza a minúsculas antes de validar y debe ser único entre
+usuarios activos, sin importar su tenant o rol. Se permite reutilizar el email
+de un usuario eliminado. Rol y tenant no son editables desde esta API.
+
+Las respuestas incluyen `id`, `nombre_apellido`, `dni`, `email`, `rol_codigo`
+y `role` (`codigo`, `nombre`). Nunca incluyen contraseña ni datos de escaneo.
+
+## Alta y acceso
+
+Se genera una contraseña aleatoria y un intento de establecimiento de contraseña
+con motivo `administrator_created`, reutilizando `createForAdminAppEmail`.
+El evento usa el canal `adminapp`; el listener existente envía el email después
+del commit mediante la cola `emails`. Requiere la configuración de correo,
+dominio AdminApp y worker existentes. No se envían contraseñas en texto plano.
+
+## Eliminación y aislamiento
+
+Las consultas de usuarios se limitan por tenant y rol `adminapp`. IDs ajenos,
+usuarios eliminados y usuarios de otros roles devuelven `404`.
+La validación de campos devuelve `422`; falta de autenticación, `401`, y rol
+no autorizado, `403`.
+
+No se permite eliminar al propio usuario ni dejar al tenant sin administradores
+(`422`, error `administrator`). La eliminación bloquea la fila del tenant dentro
+de una transacción para serializar bajas concurrentes. También verifica que el
+actor siga activo, revoca tokens y aplica el borrado lógico existente en `users`.
+
+No agrega tablas ni migraciones. No modifica el CRUD de escáneres ni el frontend.
+
+## Verificación
+
+`php artisan test tests/Feature/Administrator/AdministratorControllerTest.php`
+
+Las pruebas cubren CRUD, normalización y unicidad del email, establecimiento de
+contraseña, restricciones de rol y tenant, baja lógica, tokens y protecciones de
+eliminación. El caso de petición autenticada antes de la baja del actor se simula;
+no es una prueba con conexiones concurrentes reales.

app/Domains/Administrator/routes/api.php

@@ -0,0 +1,10 @@
+<?php
+
+use App\Domains\Administrator\Controllers\AdminAppAdministratorController;
+use Illuminate\Support\Facades\Route;
+
+Route::prefix('v1/adminapp/tenant')
+    ->middleware(['auth:sanctum', 'adminapp.tenant'])
+    ->group(function (): void {
+        Route::apiResource('administrators', AdminAppAdministratorController::class)->except('show');
+    });

app/Domains/Auth/Controllers/ResetPasswordController.php

@@ -5,6 +5,7 @@ namespace App\Domains\Auth\Controllers;
 use App\Domains\Auth\Models\ResetPasswordAttempt;
 use App\Domains\Auth\Requests\ResetPasswordRequest;
 use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Validation\ValidationException;
@@ -26,6 +27,7 @@ class ResetPasswordController extends Controller
             $data['email'],
             $data['codigo'],
             $data['password'],
+            RoleCode::from($request->route('reset_role', RoleCode::User->value)),
         )) {
             throw ValidationException::withMessages([
                 'codigo' => __('api.auth.password_reset_invalid'),

app/Domains/Auth/Controllers/ValidateResetPasswordAttemptController.php

@@ -5,6 +5,7 @@ namespace App\Domains\Auth\Controllers;
 use App\Domains\Auth\Models\ResetPasswordAttempt;
 use App\Domains\Auth\Requests\ValidateResetPasswordAttemptRequest;
 use App\Domains\Auth\Services\ResetPasswordAttemptService;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Validation\ValidationException;
@@ -25,6 +26,7 @@ class ValidateResetPasswordAttemptController extends Controller
         $result = $this->resetPasswordAttemptService->validateCode(
             $data['email'],
             $data['codigo'],
+            RoleCode::from($request->route('reset_role', RoleCode::User->value)),
         );
 
         if ($result === ResetPasswordAttemptService::CODE_EXPIRED) {

app/Domains/Auth/Models/ResetPasswordAttempt.php

@@ -17,6 +17,8 @@ class ResetPasswordAttempt extends Model
 
     public const REASON_STAFF_CREATED = 'staff_created';
 
+    public const REASON_ADMINISTRATOR_CREATED = 'administrator_created';
+
     public const STATUS_PENDING = 'pending';
 
     public const STATUS_VALIDATED = 'validated';

app/Domains/Auth/Models/User.php

@@ -6,6 +6,7 @@ use App\Domains\Authorization\Enums\RoleCode;
 use App\Domains\Authorization\Models\Role;
 use App\Domains\Catalog\Models\Category;
 use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\ScanAttempt;
 use Database\Factories\UserFactory;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Attributes\Hidden;
@@ -13,16 +14,17 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\SoftDeletes;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
 use Laravel\Sanctum\HasApiTokens;
 
 #[Fillable(['nombre_apellido', 'email', 'password', 'dni', 'telefono', 'google_id', 'rol_codigo', 'tenant_codigo'])]
-#[Hidden(['password', 'remember_token'])]
+#[Hidden(['password', 'remember_token', 'active_email', 'active_google_id'])]
 class User extends Authenticatable
 {
     /** @use HasFactory<UserFactory> */
-    use HasApiTokens, HasFactory, Notifiable;
+    use HasApiTokens, HasFactory, Notifiable, SoftDeletes;
 
     protected $attributes = [
         'rol_codigo' => RoleCode::User->value,
@@ -45,6 +47,12 @@ class User extends Authenticatable
         return $this->hasMany(LoginAttempt::class);
     }
 
+    /** @return HasMany<ScanAttempt, $this> */
+    public function scanAttempts(): HasMany
+    {
+        return $this->hasMany(ScanAttempt::class, 'scanner_user_id');
+    }
+
     /**
      * @return BelongsTo<Role, $this>
      */

app/Domains/Auth/Requests/RegisterUserRequest.php

@@ -2,6 +2,7 @@
 
 namespace App\Domains\Auth\Requests;
 
+use App\Domains\Authorization\Enums\RoleCode;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
 use Illuminate\Validation\Rules\Password;
@@ -13,15 +14,26 @@ class RegisterUserRequest extends FormRequest
         return true;
     }
 
-    /**
-     * @return array<string, mixed>
-     */
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
+    /** @return array<string, mixed> */
     public function rules(): array
     {
         return [
             'tenant_codigo' => ['nullable', 'string', Rule::exists('tenants', 'codigo')],
             'nombre_apellido' => ['required', 'string', 'max:255'],
-            'email' => ['required', 'string', 'email', 'max:255', Rule::unique('users', 'email')],
+            'email' => [
+                'required',
+                'string',
+                'email',
+                'max:255',
+                Rule::unique('users', 'active_email')->where('rol_codigo', RoleCode::User->value)->whereNull('deleted_at'),
+            ],
             'password' => ['required', 'string', 'confirmed', Password::min(8)->mixedCase()->symbols()],
             'dni' => ['nullable', 'string', 'max:255'],
             'telefono' => ['nullable', 'string', 'max:255'],

app/Domains/Auth/Requests/UpdateProfileRequest.php

@@ -4,6 +4,7 @@ namespace App\Domains\Auth\Requests;
 
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
+use Illuminate\Validation\Rules\Password;
 
 class UpdateProfileRequest extends FormRequest
 {
@@ -12,6 +13,13 @@ class UpdateProfileRequest extends FormRequest
         return true;
     }
 
+    protected function prepareForValidation(): void
+    {
+        if (is_string($this->input('email'))) {
+            $this->merge(['email' => mb_strtolower(trim($this->input('email')))]);
+        }
+    }
+
     public function rules(): array
     {
         return [
@@ -19,11 +27,13 @@ class UpdateProfileRequest extends FormRequest
             'email' => [
                 'required',
                 'email',
-                Rule::unique('users', 'email')->ignore($this->user()->id),
+                Rule::unique('users', 'active_email')->where('rol_codigo', $this->user()->rol_codigo)
+                    ->whereNull('deleted_at')
+                    ->ignore($this->user()->id),
             ],
             'dni' => ['nullable', 'string', 'regex:/^[0-9]{7,8}$/'],
             'telefono' => ['nullable', 'string', 'regex:/^\+?[0-9\s\-]+$/'],
-            'password' => ['nullable', 'string', \Illuminate\Validation\Rules\Password::min(8)->mixedCase()->symbols()],
+            'password' => ['nullable', 'string', Password::min(8)->mixedCase()->symbols()],
         ];
     }
 }

app/Domains/Auth/Resources/UserResource.php

@@ -24,6 +24,11 @@ class UserResource extends JsonResource
             'telefono' => $this->telefono,
             'rol_codigo' => $this->rol_codigo,
             'tenant_codigo' => $this->tenant_codigo,
+            'categories' => $this->whenLoaded('scanCategories', fn () => $this->scanCategories
+                ->map(fn ($category) => [
+                    'id' => $category->id,
+                    'nombre' => $category->nombre,
+                ])->values()),
         ];
     }
 }

app/Domains/Auth/Services/AdminCredentialVerifier.php

@@ -11,7 +11,7 @@ class AdminCredentialVerifier
     public function verify(string $email, string $password): bool
     {
         $admin = User::query()
-            ->where('email', mb_strtolower(trim($email)))
+            ->where('active_email', mb_strtolower(trim($email)))
             ->where('rol_codigo', RoleCode::Admin->value)
             ->first();
 

app/Domains/Auth/Services/GoogleAuthService.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Auth\Services;
 
 use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
 use App\Domains\Notification\Events\UserRegistered;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Tenant\Support\TenantDomainNormalizer;
@@ -124,12 +125,12 @@ class GoogleAuthService
             ]);
         }
 
-        $user = User::query()->where('google_id', $googleId)->first();
+        $user = User::query()->where('rol_codigo', RoleCode::User->value)->where('google_id', $googleId)->first();
         if ($user) {
             return $user;
         }
 
-        $user = User::query()->where('email', $email)->first();
+        $user = User::query()->where('rol_codigo', RoleCode::User->value)->where('active_email', mb_strtolower(trim($email)))->first();
         if ($user) {
             $user->forceFill(['google_id' => $googleId])->save();
 

app/Domains/Auth/Services/PasswordLoginService.php

@@ -85,7 +85,7 @@ class PasswordLoginService
             null,
             $ipAddress,
             $userAgent,
-            null,
+            RoleCode::Scanner,
             true,
             PermissionCode::ScanTickets->value,
             PasswordResetRequested::CHANNEL_SCANNER,
@@ -120,7 +120,7 @@ class PasswordLoginService
             $passwordResetChannel,
         ): array {
             $user = User::query()
-                ->where('email', $normalizedEmail)
+                ->where('active_email', $normalizedEmail)
                 ->when(
                     $requiredRole !== null,
                     fn ($query) => $query->where('rol_codigo', $requiredRole->value),

app/Domains/Auth/Services/ResetPasswordAttemptService.php

@@ -28,7 +28,8 @@ class ResetPasswordAttemptService
         try {
             $attemptId = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?int {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', RoleCode::User->value)
                     ->lockForUpdate()
                     ->first();
 
@@ -65,7 +66,7 @@ class ResetPasswordAttemptService
         try {
             $result = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?array {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
                     ->where('rol_codigo', RoleCode::AdminApp->value)
                     ->whereNotNull('tenant_codigo')
                     ->lockForUpdate()
@@ -113,7 +114,7 @@ class ResetPasswordAttemptService
         try {
             $result = DB::transaction(function () use ($email, $emailFingerprint, $reason): ?array {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
                     ->where('rol_codigo', RoleCode::Scanner->value)
                     ->whereNotNull('tenant_codigo')
                     ->lockForUpdate()
@@ -152,14 +153,15 @@ class ResetPasswordAttemptService
         );
     }
 
-    public function validateCode(string $email, string $code): string
+    public function validateCode(string $email, string $code, RoleCode $role = RoleCode::User): string
     {
         $emailFingerprint = $this->emailFingerprint($email);
 
         try {
-            return DB::transaction(function () use ($email, $code, $emailFingerprint): string {
+            return DB::transaction(function () use ($email, $code, $emailFingerprint, $role): string {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', $role->value)
                     ->lockForUpdate()
                     ->first();
 
@@ -207,14 +209,15 @@ class ResetPasswordAttemptService
         }
     }
 
-    public function resetPassword(string $email, string $code, string $password): bool
+    public function resetPassword(string $email, string $code, string $password, RoleCode $role = RoleCode::User): bool
     {
         $emailFingerprint = $this->emailFingerprint($email);
 
         try {
-            return DB::transaction(function () use ($email, $code, $password, $emailFingerprint): bool {
+            return DB::transaction(function () use ($email, $code, $password, $emailFingerprint, $role): bool {
                 $user = User::query()
-                    ->where('email', $email)
+                    ->where('active_email', mb_strtolower(trim($email)))
+                    ->where('rol_codigo', $role->value)
                     ->lockForUpdate()
                     ->first();
 

app/Domains/Auth/Services/ScannerContextService.php

@@ -19,6 +19,16 @@ class ScannerContextService
 
         $user->setRelation('tenant', $tenant);
 
+        if ($tenant->requiresScannerCategoryValidation()) {
+            $categories = $user->scanCategories()
+                ->orderBy('nombre')
+                ->get();
+
+            if ($categories->isNotEmpty()) {
+                $user->setRelation('scanCategories', $categories);
+            }
+        }
+
         return $user;
     }
 }

app/Domains/Auth/routes/adminapp.php

@@ -12,8 +12,10 @@ Route::prefix('v1/adminapp')->group(function (): void {
     Route::post('password/reset-attempts', CreateAdminAppResetPasswordAttemptController::class)
         ->middleware('throttle:5,1');
     Route::post('password/reset-attempts/validate', ValidateResetPasswordAttemptController::class)
+        ->defaults('reset_role', 'adminapp')
         ->middleware('throttle:10,1');
     Route::post('password/reset', ResetPasswordController::class)
+        ->defaults('reset_role', 'adminapp')
         ->middleware('throttle:5,1');
     Route::middleware(['auth:sanctum', 'adminapp.tenant'])
         ->get('me', AdminAppMeController::class);

app/Domains/Auth/routes/scanner.php

@@ -12,8 +12,10 @@ Route::prefix('v1/scanner')->group(function (): void {
     Route::post('password/reset-attempts', CreateScannerResetPasswordAttemptController::class)
         ->middleware('throttle:5,1');
     Route::post('password/reset-attempts/validate', ValidateResetPasswordAttemptController::class)
+        ->defaults('reset_role', 'scanner')
         ->middleware('throttle:10,1');
     Route::post('password/reset', ResetPasswordController::class)
+        ->defaults('reset_role', 'scanner')
         ->middleware('throttle:5,1');
     Route::middleware(['auth:sanctum', 'scanner.tenant'])
         ->get('me', ScannerMeController::class);

app/Domains/Bootstrap/Resources/AdminAppBootstrapResource.php

@@ -17,6 +17,7 @@ class AdminAppBootstrapResource extends JsonResource
 
         return [
             'website_type_code' => $websiteType->codigo,
+            'site_title' => $websiteType->site_title,
             'primary_color' => $websiteType->primary_color,
             'secondary_color' => $websiteType->secondary_color,
             'danger_color' => $websiteType->danger_color,

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/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/Services/InvitationPurchaseProvisioner.php

@@ -5,6 +5,7 @@ namespace App\Domains\Desfile\Services;
 use DateTimeInterface;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Schema;
 use Illuminate\Support\Str;
 use RuntimeException;
 
@@ -22,7 +23,7 @@ class InvitationPurchaseProvisioner
     private const ALLOCATIONS = [
         ['sector' => 'A', 'row' => 1, 'first_seat' => 1, 'last_seat' => 16, 'type' => 'NORMAL'],
         ['sector' => 'A', 'row' => 3, 'first_seat' => 1, 'last_seat' => 14, 'type' => 'NORMAL'],
-        ['sector' => 'C', 'row' => 1, 'first_seat' => 1, 'last_seat' => 16, 'type' => 'VIP + LUNCH'],
+        ['sector' => 'C', 'row' => 1, 'first_seat' => 1, 'last_seat' => 17, 'type' => 'VIP + LUNCH'],
         ['sector' => 'C', 'row' => 3, 'first_seat' => 6, 'last_seat' => 7, 'type' => 'NORMAL'],
     ];
 
@@ -58,7 +59,7 @@ class InvitationPurchaseProvisioner
                         $allocation['type'],
                     );
 
-                    $this->createPurchaseItem(
+                    $purchaseItemId = $this->createPurchaseItem(
                         $purchaseId,
                         $catalogItem,
                         $variant,
@@ -70,6 +71,7 @@ class InvitationPurchaseProvisioner
                     );
                     $this->createTicketAndCommitStock(
                         $purchaseId,
+                        $purchaseItemId,
                         $userId,
                         (int) $catalogItem->id,
                         $variant,
@@ -102,7 +104,11 @@ class InvitationPurchaseProvisioner
 
     private function userId(DateTimeInterface $now): int
     {
-        $user = DB::table('users')->where('email', self::USER_EMAIL)->first();
+        $user = DB::table('users')
+            ->where('active_email', self::USER_EMAIL)
+            ->where('rol_codigo', 'user')
+            ->whereNull('deleted_at')
+            ->first();
 
         if ($user !== null) {
             if ($user->tenant_codigo !== self::TENANT_CODE) {
@@ -326,12 +332,13 @@ class InvitationPurchaseProvisioner
         int $seat,
         string $type,
         DateTimeInterface $now,
-    ): void {
-        if (DB::table('compra_items')
+    ): int {
+        $existingId = DB::table('compra_items')
             ->where('compra_id', $purchaseId)
             ->where('source_variant_id', $variant->id)
-            ->exists()) {
-            return;
+            ->value('id');
+        if ($existingId !== null) {
+            return (int) $existingId;
         }
 
         $attributes = [
@@ -341,7 +348,7 @@ class InvitationPurchaseProvisioner
             ['name' => 'Asiento', 'value' => (string) $seat],
         ];
 
-        DB::table('compra_items')->insert([
+        return DB::table('compra_items')->insertGetId([
             'compra_id' => $purchaseId,
             'source_catalog_item_id' => $catalogItem->id,
             'source_variant_id' => $variant->id,
@@ -367,13 +374,18 @@ class InvitationPurchaseProvisioner
 
     private function createTicketAndCommitStock(
         int $purchaseId,
+        int $purchaseItemId,
         int $userId,
         int $catalogItemId,
         object $variant,
         DateTimeInterface $now,
     ): void {
+        $purchaseReference = Schema::hasColumn('tickets', 'source_purchase_item_id')
+            ? ['source_purchase_item_id' => $purchaseItemId]
+            : ['source_purchase_id' => $purchaseId];
+
         if (DB::table('tickets')
-            ->where('source_purchase_id', $purchaseId)
+            ->where($purchaseReference)
             ->where('source_variant_id', $variant->id)
             ->exists()) {
             return;
@@ -420,7 +432,7 @@ class InvitationPurchaseProvisioner
             'ticket' => (string) Str::uuid(),
             'name' => null,
             'description' => null,
-            'source_purchase_id' => $purchaseId,
+            ...$purchaseReference,
             'source_catalog_item_id' => $catalogItemId,
             'source_variant_id' => $variant->id,
             'used_at' => null,

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/Event/Controllers/AdminApp/EventController.php

@@ -2,7 +2,11 @@
 
 namespace App\Domains\Event\Controllers\AdminApp;
 
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Event\Requests\RescheduleEventDateRequest;
+use App\Domains\Event\Requests\StoreEventDateRequest;
 use App\Domains\Event\Requests\UpdateEventRequest;
+use App\Domains\Event\Resources\EventDateResource;
 use App\Domains\Event\Resources\EventResource;
 use App\Domains\Event\Services\EventService;
 use App\Http\Controllers\Controller;
@@ -28,4 +32,37 @@ class EventController extends Controller
             )
         );
     }
+
+    public function storeDate(StoreEventDateRequest $request): EventDateResource
+    {
+        return EventDateResource::make(
+            $this->eventService->createDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $request->validated(),
+            )
+        );
+    }
+
+    public function rescheduleDate(
+        RescheduleEventDateRequest $request,
+        EventDate $eventDate,
+    ): EventDateResource {
+        return EventDateResource::make(
+            $this->eventService->rescheduleDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $eventDate,
+                $request->validated(),
+            )
+        );
+    }
+
+    public function suspendDate(Request $request, EventDate $eventDate): EventDateResource
+    {
+        return EventDateResource::make(
+            $this->eventService->suspendDateForTenant(
+                $request->user()->tenant()->firstOrFail(),
+                $eventDate,
+            )
+        );
+    }
 }

app/Domains/Event/Enums/EventDateStatus.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Domains\Event\Enums;
+
+enum EventDateStatus: string
+{
+    case Rescheduled = 'rescheduled';
+    case Suspended = 'suspended';
+    case Scheduled = 'scheduled';
+    case InProgress = 'in_progress';
+    case Completed = 'completed';
+}

app/Domains/Event/Models/EventDate.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Event\Models;
 
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Event\Enums\EventDateStatus;
 use App\Domains\Event\Services\EventDateTextFormatter;
 use App\Domains\Tenant\Models\Tenant;
 use App\Domains\Ticket\Enums\ValidityTimeType;
@@ -21,6 +22,8 @@ use Illuminate\Support\Carbon;
     'date',
     'time_start',
     'time_end',
+    'rescheduled_to_event_date_id',
+    'suspended_at',
 ])]
 class EventDate extends Model
 {
@@ -28,6 +31,8 @@ class EventDate extends Model
 
     public $timestamps = false;
 
+    protected $appends = ['status'];
+
     protected static function booted(): void
     {
         static::creating(fn (self $eventDate) => $eventDate->syncValidityTime());
@@ -52,6 +57,8 @@ class EventDate extends Model
         return [
             'date' => 'date:Y-m-d',
             'validity_time_id' => 'integer',
+            'rescheduled_to_event_date_id' => 'integer',
+            'suspended_at' => 'datetime',
         ];
     }
 
@@ -67,6 +74,18 @@ class EventDate extends Model
         return $this->belongsTo(ValidityTime::class);
     }
 
+    /** @return BelongsTo<EventDate, $this> */
+    public function rescheduledTo(): BelongsTo
+    {
+        return $this->belongsTo(self::class, 'rescheduled_to_event_date_id');
+    }
+
+    /** @return HasMany<EventDate, $this> */
+    public function rescheduledFrom(): HasMany
+    {
+        return $this->hasMany(self::class, 'rescheduled_to_event_date_id');
+    }
+
     /** @return HasMany<Variant, $this> */
     public function variants(): HasMany
     {
@@ -94,6 +113,27 @@ class EventDate extends Model
         return Carbon::parse($this->date->format('Y-m-d').' '.$this->time_end);
     }
 
+    public function getStatusAttribute(): EventDateStatus
+    {
+        if ($this->rescheduled_to_event_date_id !== null) {
+            return EventDateStatus::Rescheduled;
+        }
+
+        if ($this->suspended_at !== null) {
+            return EventDateStatus::Suspended;
+        }
+
+        if (now()->lt($this->startsAt())) {
+            return EventDateStatus::Scheduled;
+        }
+
+        if (now()->lt($this->endsAt())) {
+            return EventDateStatus::InProgress;
+        }
+
+        return EventDateStatus::Completed;
+    }
+
     private function syncTenantDateText(): void
     {
         $tenant = $this->tenant()->first();
@@ -104,7 +144,10 @@ class EventDate extends Model
 
         $tenant->update([
             'event_date_text' => app(EventDateTextFormatter::class)->format(
-                $tenant->eventDates()->pluck('date')
+                $tenant->eventDates()
+                    ->whereNull('rescheduled_to_event_date_id')
+                    ->whereNull('suspended_at')
+                    ->pluck('date')
             ),
         ]);
     }

app/Domains/Event/Requests/RescheduleEventDateRequest.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Event\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class RescheduleEventDateRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'date' => ['required', 'date_format:Y-m-d'],
+        ];
+    }
+}

app/Domains/Event/Requests/StoreEventDateRequest.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Domains\Event\Requests;
+
+use Illuminate\Foundation\Http\FormRequest;
+
+class StoreEventDateRequest extends FormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    /** @return array<string, mixed> */
+    public function rules(): array
+    {
+        return [
+            'date' => ['required', 'date_format:Y-m-d'],
+            'start_time' => ['required', 'date_format:H:i'],
+            'end_time' => ['required', 'date_format:H:i'],
+        ];
+    }
+}

app/Domains/Event/Requests/UpdateEventRequest.php

@@ -19,11 +19,6 @@ class UpdateEventRequest extends FormRequest
         return [
             'title' => ['required', 'string', 'max:255'],
             'location' => ['required', 'string', 'max:255'],
-            'dates' => ['required', 'array', 'min:1'],
-            'dates.*' => ['required', 'array:date,start_time,end_time'],
-            'dates.*.date' => ['required', 'date_format:Y-m-d', 'distinct'],
-            'dates.*.start_time' => ['required', 'date_format:H:i'],
-            'dates.*.end_time' => ['required', 'date_format:H:i'],
             'social_media' => ['sometimes', 'array'],
             'social_media.*' => ['required', 'array:code,url,orden'],
             'social_media.*.code' => [
@@ -38,6 +33,16 @@ class UpdateEventRequest extends FormRequest
             'contact.whatsapp_url' => ['nullable', 'url', 'max:2048'],
             'contact.instagram_url' => ['nullable', 'url', 'max:2048'],
             'contact.facebook_url' => ['nullable', 'url', 'max:2048'],
+            'allow_ticket_refund' => ['sometimes', 'boolean'],
+            'allow_ticket_total_refund' => ['sometimes', 'boolean'],
+            'allow_ticket_partial_refund' => ['sometimes', 'boolean'],
+            'ticket_partial_refund_percentage' => [
+                'sometimes',
+                'numeric',
+                'decimal:0,2',
+                'min:0',
+                'max:99.99',
+            ],
         ];
     }
 
@@ -54,6 +59,41 @@ class UpdateEventRequest extends FormRequest
                         'The social media field is required.'
                     );
                 }
+
+                if (! array_key_exists('allow_ticket_refund', $input)) {
+                    return;
+                }
+
+                foreach ([
+                    'allow_ticket_total_refund',
+                    'allow_ticket_partial_refund',
+                    'ticket_partial_refund_percentage',
+                ] as $field) {
+                    if (! array_key_exists($field, $input)) {
+                        $validator->errors()->add($field, 'El campo es obligatorio.');
+                    }
+                }
+
+                $totalEnabled = $this->boolean('allow_ticket_total_refund');
+                $partialEnabled = $this->boolean('allow_ticket_partial_refund');
+
+                $refundEnabled = $this->boolean('allow_ticket_refund');
+
+                if ($refundEnabled && ! $totalEnabled && ! $partialEnabled) {
+                    $validator->errors()->add(
+                        'allow_ticket_refund',
+                        'Seleccioná al menos un tipo de reembolso.'
+                    );
+                }
+
+                if ($refundEnabled
+                    && $partialEnabled
+                    && (float) ($input['ticket_partial_refund_percentage'] ?? 0) <= 0) {
+                    $validator->errors()->add(
+                        'ticket_partial_refund_percentage',
+                        'Ingresá un porcentaje mayor que cero para el reembolso parcial.'
+                    );
+                }
             },
         ];
     }

app/Domains/Event/Resources/EventDateResource.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Domains\Event\Resources;
+
+use App\Domains\Event\Models\EventDate;
+use App\Domains\Ticket\Resources\ValidityTimeResource;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+/** @mixin EventDate */
+class EventDateResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'validity_time_id' => $this->validity_time_id,
+            'validity_time' => ValidityTimeResource::make($this->whenLoaded('validityTime')),
+            'date' => $this->date->format('Y-m-d'),
+            'start_time' => substr($this->time_start, 0, 5),
+            'end_time' => substr($this->time_end, 0, 5),
+            'status' => $this->status->value,
+            'rescheduled_to_event_date_id' => $this->rescheduled_to_event_date_id,
+            'suspended_at' => $this->suspended_at?->toISOString(),
+        ];
+    }
+}

app/Domains/Event/Resources/EventResource.php

@@ -3,7 +3,6 @@
 namespace App\Domains\Event\Resources;
 
 use App\Domains\Tenant\Models\Tenant;
-use App\Domains\Ticket\Resources\ValidityTimeResource;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
 
@@ -19,14 +18,11 @@ class EventResource extends JsonResource
             'id' => $this->id,
             'title' => $this->event_title,
             'location' => $this->event_location,
-            'dates' => $this->eventDates->map(fn ($eventDate): array => [
-                'id' => $eventDate->id,
-                'validity_time_id' => $eventDate->validity_time_id,
-                'validity_time' => ValidityTimeResource::make($eventDate->validityTime),
-                'date' => $eventDate->date->format('Y-m-d'),
-                'start_time' => substr($eventDate->time_start, 0, 5),
-                'end_time' => substr($eventDate->time_end, 0, 5),
-            ])->values(),
+            'allow_ticket_refund' => $this->allow_ticket_refund,
+            'allow_ticket_total_refund' => $this->allow_ticket_total_refund,
+            'allow_ticket_partial_refund' => $this->allow_ticket_partial_refund,
+            'ticket_partial_refund_percentage' => $this->ticket_partial_refund_percentage,
+            'dates' => EventDateResource::collection($this->eventDates),
             'social_media' => $this->socialMedia->map(fn ($item): array => [
                 'code' => $item->code,
                 'url' => $item->pivot->url,

app/Domains/Event/Services/EffectiveEventDateResolver.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Domains\Event\Services;
+
+use App\Domains\Event\Models\EventDate;
+
+class EffectiveEventDateResolver
+{
+    public function resolve(EventDate $eventDate): ?EventDate
+    {
+        $current = $eventDate;
+        $visited = [];
+
+        while (true) {
+            $identity = $current->getKey() === null
+                ? 'object:'.spl_object_id($current)
+                : 'key:'.$current->getKey();
+
+            if (isset($visited[$identity])) {
+                return null;
+            }
+
+            $visited[$identity] = true;
+
+            if ($current->rescheduled_to_event_date_id === null) {
+                return $current->suspended_at === null ? $current : null;
+            }
+
+            $current->loadMissing('rescheduledTo');
+            $current = $current->rescheduledTo;
+
+            if ($current === null) {
+                return null;
+            }
+        }
+    }
+}

app/Domains/Event/Services/EventService.php

@@ -2,7 +2,10 @@
 
 namespace App\Domains\Event\Services;
 
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Event\Models\EventDate;
 use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Validation\ValidationException;
 
@@ -14,6 +17,10 @@ class EventService
         'facebook_url' => 'facebook',
     ];
 
+    public function __construct(
+        private readonly EffectiveEventDateResolver $effectiveEventDateResolver,
+    ) {}
+
     public function forTenant(Tenant $tenant): Tenant
     {
         return $tenant->load(['eventDates.validityTime', 'socialMedia']);
@@ -27,9 +34,14 @@ class EventService
             $tenant->update([
                 'event_title' => $data['title'],
                 'event_location' => $data['location'],
+                ...array_intersect_key($data, array_flip([
+                    'allow_ticket_refund',
+                    'allow_ticket_total_refund',
+                    'allow_ticket_partial_refund',
+                    'ticket_partial_refund_percentage',
+                ])),
             ]);
 
-            $this->syncDates($tenant, $data['dates']);
             if (array_key_exists('social_media', $data)) {
                 $this->syncSocialMedia($tenant, $data['social_media']);
             } else {
@@ -40,41 +52,185 @@ class EventService
         });
     }
 
-    /** @param array<int, array{date: string, start_time: string, end_time: string}> $dates */
-    private function syncDates(Tenant $tenant, array $dates): void
+    /** @param array{date: string, start_time: string, end_time: string} $data */
+    public function createDateForTenant(Tenant $tenant, array $data): EventDate
     {
-        $existingDates = $tenant->eventDates()->get()->values();
+        return DB::transaction(function () use ($tenant, $data): EventDate {
+            $attributes = $this->dateAttributes($data);
 
-        foreach (array_values($dates) as $index => $date) {
-            $attributes = [
-                'date' => $date['date'],
-                'time_start' => $date['start_time'],
-                'time_end' => $date['end_time'],
-            ];
+            if ($tenant->eventDates()->where($attributes)->exists()) {
+                throw ValidationException::withMessages([
+                    'date' => ['La fecha y el horario ya existen.'],
+                ]);
+            }
 
-            $existingDate = $existingDates->get($index);
+            return $tenant->eventDates()->create($attributes)->load('validityTime');
+        });
+    }
 
-            if ($existingDate) {
-                $existingDate->update($attributes);
-            } else {
-                $tenant->eventDates()->create($attributes);
+    /** @param array{date: string} $data */
+    public function rescheduleDateForTenant(Tenant $tenant, EventDate $eventDate, array $data): EventDate
+    {
+        return DB::transaction(function () use ($tenant, $eventDate, $data): EventDate {
+            $source = $this->lockedDateForTenant($tenant, $eventDate);
+
+            if ($source->suspended_at !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['No se puede reprogramar una fecha suspendida.'],
+                ]);
+            }
+
+            if ($source->rescheduled_to_event_date_id !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['La fecha ya fue reprogramada.'],
+                ]);
+            }
+
+            $destination = $tenant->eventDates()
+                ->whereDate('date', $data['date'])
+                ->lockForUpdate()
+                ->first();
+
+            if ($destination === null) {
+                $destination = $tenant->eventDates()->create([
+                    'date' => $data['date'],
+                    'time_start' => $source->time_start,
+                    'time_end' => $source->time_end,
+                ]);
+            }
+
+            if ($destination->is($source) || $this->chainContains($destination, $source)) {
+                throw ValidationException::withMessages([
+                    'date' => ['La reprogramación generaría una referencia circular.'],
+                ]);
+            }
+
+            if ($this->effectiveEventDateResolver->resolve($destination) === null) {
+                throw ValidationException::withMessages([
+                    'date' => ['La fecha de destino no es utilizable.'],
+                ]);
+            }
+
+            $source->update(['rescheduled_to_event_date_id' => $destination->getKey()]);
+
+            return $source->fresh(['validityTime', 'rescheduledTo.validityTime']);
+        });
+    }
+
+    public function suspendDateForTenant(Tenant $tenant, EventDate $eventDate): EventDate
+    {
+        return DB::transaction(function () use ($tenant, $eventDate): EventDate {
+            $date = $this->lockedDateForTenant($tenant, $eventDate);
+
+            if ($date->rescheduled_to_event_date_id !== null) {
+                throw ValidationException::withMessages([
+                    'event_date' => ['No se puede suspender una fecha que ya fue reprogramada.'],
+                ]);
+            }
+
+            if ($date->suspended_at !== null) {
+                return $date->load('validityTime');
+            }
+
+            $date->update(['suspended_at' => now()]);
+            $this->disableTicketsWithoutUsableDates($tenant, $date);
+
+            return $date->fresh('validityTime');
+        });
+    }
+
+    private function lockedDateForTenant(Tenant $tenant, EventDate $eventDate): EventDate
+    {
+        return $tenant->eventDates()
+            ->whereKey($eventDate->getKey())
+            ->lockForUpdate()
+            ->firstOrFail();
+    }
+
+    private function chainContains(EventDate $start, EventDate $expected): bool
+    {
+        $current = $start;
+        $visited = [];
+
+        while ($current->rescheduled_to_event_date_id !== null) {
+            if ($current->is($expected)) {
+                return true;
+            }
+
+            if (isset($visited[$current->getKey()])) {
+                return true;
+            }
+
+            $visited[$current->getKey()] = true;
+            $current = $current->rescheduledTo()->lockForUpdate()->first();
+
+            if ($current === null) {
+                return false;
             }
         }
 
-        $datesToDelete = $existingDates->slice(count($dates));
+        return $current->is($expected);
+    }
 
-        if ($datesToDelete->contains(fn ($eventDate): bool => $eventDate
-            ->selectedByVariants()
-            ->whereHas('sourceTickets')
-            ->exists()
-            || $eventDate->variants()->whereHas('sourceTickets')->exists())) {
-            throw ValidationException::withMessages([
-                'dates' => ['No se puede eliminar una fecha utilizada por tickets generados.'],
-            ]);
+    private function disableTicketsWithoutUsableDates(Tenant $tenant, EventDate $suspendedDate): void
+    {
+        $affectedDateIds = collect([$suspendedDate->getKey()]);
+        $frontier = $affectedDateIds;
+
+        while ($frontier->isNotEmpty()) {
+            $predecessors = $tenant->eventDates()
+                ->whereIn('rescheduled_to_event_date_id', $frontier)
+                ->pluck('id')
+                ->diff($affectedDateIds)
+                ->values();
+            $affectedDateIds = $affectedDateIds->merge($predecessors)->unique()->values();
+            $frontier = $predecessors;
         }
 
-        $datesToDelete->each->delete();
-        $tenant->unsetRelation('eventDates');
+        $variants = Variant::withTrashed()
+            ->where(function ($query) use ($affectedDateIds): void {
+                $query->whereIn('event_date_id', $affectedDateIds)
+                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
+                        ->whereIn('event_dates.id', $affectedDateIds));
+            })
+            ->with(['eventDates', 'eventDate'])
+            ->get();
+
+        foreach ($variants as $variant) {
+            $hasUsableDate = $variant->selectedEventDates()->contains(
+                fn (EventDate $candidate): bool => $this->effectiveEventDateResolver->resolve($candidate) !== null
+            );
+
+            if ($hasUsableDate) {
+                continue;
+            }
+
+            Ticket::query()
+                ->where('tenant_code', $tenant->codigo)
+                ->where('source_variant_id', $variant->getKey())
+                ->whereNull('disabled_at')
+                ->whereNull('cancelled_at')
+                ->whereNull('refunded_at')
+                ->lockForUpdate()
+                ->get()
+                ->each(function (Ticket $ticket): void {
+                    $ticket->markAsDisabled();
+                    $ticket->save();
+                });
+        }
+    }
+
+    /**
+     * @param  array{date: string, start_time: string, end_time: string}  $data
+     * @return array{date: string, time_start: string, time_end: string}
+     */
+    private function dateAttributes(array $data): array
+    {
+        return [
+            'date' => $data['date'],
+            'time_start' => $data['start_time'].':00',
+            'time_end' => $data['end_time'].':00',
+        ];
     }
 
     /** @param array<string, string|null> $contact */

app/Domains/Event/routes/adminapp.php

@@ -8,4 +8,7 @@ Route::prefix('v1/adminapp/tenant')
     ->group(function (): void {
         Route::get('event', [EventController::class, 'show']);
         Route::put('event', [EventController::class, 'update']);
+        Route::post('event-dates', [EventController::class, 'storeDate']);
+        Route::post('event-dates/{eventDate}/reschedule', [EventController::class, 'rescheduleDate']);
+        Route::post('event-dates/{eventDate}/suspend', [EventController::class, 'suspendDate']);
     });

app/Domains/Forms/Controllers/AdminApp/TicketFilterFormController.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Forms\Controllers\AdminApp;
+
+use App\Domains\Forms\Resources\TicketFilterFormResource;
+use App\Domains\Forms\Services\TicketFilterFormService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class TicketFilterFormController extends Controller
+{
+    public function __construct(private readonly TicketFilterFormService $formService) {}
+
+    public function __invoke(Request $request): TicketFilterFormResource
+    {
+        $tenant = $request->user('sanctum')->tenant()->firstOrFail();
+
+        return TicketFilterFormResource::make($this->formService->get($tenant));
+    }
+}

app/Domains/Forms/Controllers/AdminApp/TicketFormController.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Domains\Forms\Controllers\AdminApp;
+
+use App\Domains\Forms\Resources\TicketFormResource;
+use App\Domains\Forms\Services\TicketFormService;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+
+class TicketFormController extends Controller
+{
+    public function __construct(protected TicketFormService $ticketFormService) {}
+
+    public function __invoke(Request $request): TicketFormResource
+    {
+        return TicketFormResource::make(
+            $this->ticketFormService->get(
+                $request->user('sanctum')->tenant()->firstOrFail()
+            )
+        );
+    }
+}

app/Domains/Forms/Resources/TicketFilterFormResource.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Forms\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class TicketFilterFormResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'code' => $this->resource['code'],
+            'action' => $this->resource['action'],
+            'method' => $this->resource['method'],
+            'fields' => $this->resource['fields'],
+            'columns' => $this->resource['columns'],
+        ];
+    }
+}

app/Domains/Forms/Resources/TicketFormResource.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Domains\Forms\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class TicketFormResource extends JsonResource
+{
+    /** @return array<string, mixed> */
+    public function toArray(Request $request): array
+    {
+        return [
+            'statuses' => $this->resource['statuses'],
+            'categories' => $this->resource['categories'],
+        ];
+    }
+}

app/Domains/Forms/Services/SaleFormService.php

@@ -6,27 +6,18 @@ use App\Domains\Purchase\Models\Purchase;
 
 class SaleFormService
 {
-    /** @return array{statuses: list<array{code: string, name: string}>} */
+    /** @return array{statuses: list<array{value: string, label: string, real_statuses: list<string>}>} */
     public function get(): array
     {
-        $names = [
-            Purchase::STATUS_CREATED => 'Creada',
-            Purchase::STATUS_PENDING_PAYMENT => 'Esperando pago',
-            Purchase::STATUS_IN_REVIEW => 'En revisión',
-            Purchase::STATUS_PAID => 'Confirmada',
-            Purchase::STATUS_CANCELLED => 'Cancelada',
-            Purchase::STATUS_REJECTED => 'Rechazada',
-            Purchase::STATUS_EXPIRED => 'Vencida',
-            Purchase::STATUS_SUPERSEDED => 'Reemplazada',
-        ];
-
         return [
             'statuses' => array_map(
-                fn (string $status): array => [
-                    'code' => $status,
-                    'name' => $names[$status],
+                fn (string $code, array $definition): array => [
+                    'value' => $code,
+                    'label' => $definition['name'],
+                    'real_statuses' => $definition['statuses'],
                 ],
-                Purchase::statuses(),
+                array_keys(Purchase::adminStatuses()),
+                array_values(Purchase::adminStatuses()),
             ),
         ];
     }

app/Domains/Forms/Services/TicketFilterFormService.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace App\Domains\Forms\Services;
+
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use App\Domains\Ticket\Services\AdminAppTicketColumnService;
+
+class TicketFilterFormService
+{
+    private const FIESTA_FUTBOL_INFANTIL = 'fiesta_futbol_infantil';
+
+    public function __construct(
+        private readonly TicketFormService $ticketFormService,
+        private readonly AdminAppTicketColumnService $columnService,
+    ) {}
+
+    /** @return array<string, mixed> */
+    public function get(Tenant $tenant): array
+    {
+        $fields = $this->commonFields();
+
+        if ($tenant->codigo === self::FIESTA_FUTBOL_INFANTIL) {
+            $fields = [
+                ...$this->fiestaFutbolInfantilFields($tenant),
+                ...$this->commonFields(includeDate: false),
+            ];
+        }
+
+        return [
+            'code' => 'tickets_filter',
+            'action' => '/api/v1/adminapp/tenant/tickets',
+            'method' => 'GET',
+            'fields' => $fields,
+            'columns' => $this->columnService->publicColumns($tenant),
+        ];
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function fiestaFutbolInfantilFields(Tenant $tenant): array
+    {
+        $form = $this->ticketFormService->getForFilters($tenant);
+
+        return [
+            [
+                'name' => 'category',
+                'query_param' => 'category',
+                'label' => 'Categoría',
+                'type' => 'select',
+                'required' => false,
+                'default' => null,
+                'placeholder' => 'Categoría',
+                'options' => array_map(
+                    fn (array $category): array => [
+                        'value' => $category['value'],
+                        'label' => $category['label'],
+                        'children' => [
+                            [
+                                'field' => 'product',
+                                'disabled' => $category['products'] === [],
+                                'options' => array_map(
+                                    fn (array $product): array => [
+                                        'value' => $product['value'],
+                                        'label' => $product['label'],
+                                        'children' => [
+                                            [
+                                                'field' => 'type',
+                                                'disabled' => $product['types'] === [],
+                                                'options' => array_map(
+                                                    fn (array $type): array => [
+                                                        'value' => $type['value'],
+                                                        'label' => $type['label'],
+                                                        'children' => [[
+                                                            'field' => 'size',
+                                                            'disabled' => ($type['sizes'] ?? []) === [],
+                                                            'options' => $type['sizes'] ?? [],
+                                                        ]],
+                                                    ],
+                                                    $product['types'],
+                                                ),
+                                            ],
+                                        ],
+                                    ],
+                                    $category['products'],
+                                ),
+                            ],
+                            [
+                                'field' => 'date',
+                                'disabled' => ! in_array($category['value'], ['comidas', 'comida'], true),
+                                'options' => [],
+                            ],
+                        ],
+                    ],
+                    $form['categories'],
+                ),
+            ],
+            $this->dependentSelect('product', 'Producto', 'category'),
+            $this->dependentSelect('type', 'Tipo', 'product'),
+            $this->dependentSelect('size', 'Talle', 'type'),
+            [
+                ...$this->dependentSelect('date', 'Fecha', 'category'),
+                'type' => 'date',
+            ],
+        ];
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function commonFields(bool $includeDate = true): array
+    {
+        return [
+            ...($includeDate ? [[
+                'name' => 'date',
+                'query_param' => 'date',
+                'label' => 'Fecha',
+                'type' => 'date',
+                'required' => false,
+                'default' => null,
+            ]] : []),
+            [
+                'name' => 'status',
+                'query_param' => 'status',
+                'label' => 'Estado',
+                'type' => 'select',
+                'required' => false,
+                'default' => null,
+                'placeholder' => 'Estado',
+                'options' => Ticket::statusOptions(),
+            ],
+        ];
+    }
+
+    /** @return array<string, mixed> */
+    private function dependentSelect(string $name, string $label, string $dependency): array
+    {
+        return [
+            'name' => $name,
+            'query_param' => $name,
+            'label' => $label,
+            'type' => 'select',
+            'required' => false,
+            'default' => null,
+            'placeholder' => $label,
+            'depends_on' => $dependency,
+            'disabled' => true,
+            'options' => [],
+        ];
+    }
+}

app/Domains/Forms/Services/TicketFormService.php

@@ -0,0 +1,396 @@
+<?php
+
+namespace App\Domains\Forms\Services;
+
+use App\Domains\Catalog\Models\CatalogItem;
+use App\Domains\Catalog\Models\Variant;
+use App\Domains\Tenant\Models\Tenant;
+use App\Domains\Ticket\Models\Ticket;
+use Illuminate\Database\Eloquent\Collection;
+
+class TicketFormService
+{
+    private const PRODUCT = 'product';
+
+    /**
+     * @var array<string, array{label: string|null, product: string, type: string|null, order: int}>
+     */
+    private const CATEGORY_PRESENTATIONS = [
+        'entradas' => [
+            'label' => null,
+            'product' => self::PRODUCT,
+            'type' => null,
+            'order' => 1,
+        ],
+        'alojamientos' => [
+            'label' => 'Camping',
+            'product' => 'tipo_alojamiento',
+            'type' => null,
+            'order' => 2,
+        ],
+        'camping' => [
+            'label' => null,
+            'product' => 'tipo_alojamiento',
+            'type' => null,
+            'order' => 2,
+        ],
+        'comidas' => [
+            'label' => 'Comida',
+            'product' => 'event_date',
+            'type' => 'horario',
+            'order' => 3,
+        ],
+        'comida' => [
+            'label' => null,
+            'product' => 'event_date',
+            'type' => 'horario',
+            'order' => 3,
+        ],
+        'merchandising' => [
+            'label' => null,
+            'product' => self::PRODUCT,
+            'type' => 'color',
+            'order' => 4,
+        ],
+    ];
+
+    /**
+     * @var array<string, array{label: string|null, product: string, type: string|null, size: string|null, order: int}>
+     */
+    private const FILTER_CATEGORY_PRESENTATIONS = [
+        'entradas' => ['label' => null, 'product' => self::PRODUCT, 'type' => null, 'size' => null, 'order' => 1],
+        'alojamientos' => ['label' => 'Camping', 'product' => 'tipo_alojamiento', 'type' => null, 'size' => null, 'order' => 2],
+        'camping' => ['label' => null, 'product' => 'tipo_alojamiento', 'type' => null, 'size' => null, 'order' => 2],
+        'comidas' => ['label' => 'Comida', 'product' => 'horario', 'type' => 'servicio', 'size' => null, 'order' => 3],
+        'comida' => ['label' => null, 'product' => 'horario', 'type' => 'servicio', 'size' => null, 'order' => 3],
+        'merchandising' => ['label' => null, 'product' => self::PRODUCT, 'type' => 'color', 'size' => 'talle', 'order' => 4],
+    ];
+
+    /**
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    public function get(Tenant $tenant): array
+    {
+        $items = CatalogItem::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->where('has_tickets', true)
+            ->whereHas('category')
+            ->with($this->relations())
+            ->orderBy('group_order')
+            ->orderBy('nombre')
+            ->get();
+
+        return $this->build($items, self::CATEGORY_PRESENTATIONS);
+    }
+
+    /**
+     * Return active catalog options plus soft-deleted sources still referenced by
+     * tickets, so historical tickets never become impossible to filter.
+     *
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    public function getForFilters(Tenant $tenant): array
+    {
+        $historicalVariantIds = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereNotNull('source_variant_id')
+            ->distinct()
+            ->pluck('source_variant_id')
+            ->map(fn ($id): int => (int) $id)
+            ->all();
+        $historicalCatalogItemIds = Ticket::query()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereNotNull('source_catalog_item_id')
+            ->distinct()
+            ->pluck('source_catalog_item_id')
+            ->map(fn ($id): int => (int) $id)
+            ->merge(
+                Variant::withTrashed()
+                    ->whereKey($historicalVariantIds)
+                    ->pluck('catalog_item_id')
+                    ->map(fn ($id): int => (int) $id),
+            )
+            ->unique()
+            ->values()
+            ->all();
+
+        $items = CatalogItem::withTrashed()
+            ->where('tenant_code', $tenant->codigo)
+            ->whereHas('category')
+            ->where(function ($query) use ($historicalCatalogItemIds): void {
+                $query
+                    ->where(function ($activeQuery): void {
+                        $activeQuery
+                            ->whereNull('catalog_items.deleted_at')
+                            ->where('has_tickets', true);
+                    })
+                    ->orWhereIn('catalog_items.id', $historicalCatalogItemIds);
+            })
+            ->with([
+                'category',
+                'itemAttributes.attribute.options',
+                'variants' => fn ($query) => $query
+                    ->withTrashed()
+                    ->where(function ($variantQuery) use ($historicalVariantIds): void {
+                        $variantQuery
+                            ->whereNull('variantes.deleted_at')
+                            ->orWhereIn('variantes.id', $historicalVariantIds);
+                    }),
+                'variants.definitions.itemAttribute.attribute.options',
+                'variants.eventDates',
+                'variants.eventDate',
+            ])
+            ->orderBy('group_order')
+            ->orderBy('nombre')
+            ->get();
+
+        return $this->build($items, self::FILTER_CATEGORY_PRESENTATIONS, includeSizes: true);
+    }
+
+    /**
+     * @param  Collection<int, CatalogItem>  $items
+     * @return array{
+     *     statuses: list<array{value: string, label: string}>,
+     *     categories: list<array{
+     *         value: string,
+     *         label: string,
+     *         products: list<array{
+     *             value: string,
+     *             label: string,
+     *             types: list<array{value: string, label: string}>
+     *         }>
+     *     }>
+     * }
+     */
+    private function build(Collection $items, array $presentations, bool $includeSizes = false): array
+    {
+        $categories = [];
+
+        foreach ($items as $item) {
+            $sourceCategory = trim((string) $item->category?->nombre);
+            $categoryValue = mb_strtolower($sourceCategory);
+            $presentation = $presentations[$categoryValue] ?? [
+                'label' => null,
+                'product' => self::PRODUCT,
+                'type' => null,
+                'size' => null,
+                'order' => PHP_INT_MAX,
+            ];
+
+            $categories[$categoryValue] ??= [
+                'value' => $categoryValue,
+                'label' => $presentation['label'] ?? $sourceCategory,
+                'order' => $presentation['order'],
+                'products' => [],
+            ];
+
+            foreach ($this->products(
+                $item,
+                $presentation['product'],
+                $presentation['type'],
+                $presentation['size'] ?? null,
+            ) as $product) {
+                $productValue = $product['value'];
+                $existingProduct = $categories[$categoryValue]['products'][$productValue] ?? [
+                    'value' => $productValue,
+                    'label' => $product['label'],
+                    'types' => [],
+                    'sizes' => [],
+                ];
+
+                foreach ($product['types'] as $type) {
+                    $existingProduct['types'][$type['value']] = $type;
+                }
+
+                foreach ($product['sizes'] as $size) {
+                    $existingProduct['sizes'][$size['value']] = $size;
+                }
+
+                $categories[$categoryValue]['products'][$productValue] = $existingProduct;
+            }
+        }
+
+        uasort($categories, fn (array $left, array $right): int => $left['order'] <=> $right['order']
+            ?: $left['label'] <=> $right['label']);
+
+        return [
+            'statuses' => Ticket::statusOptions(),
+            'categories' => array_values(array_map(
+                fn (array $category): array => [
+                    'value' => $category['value'],
+                    'label' => $category['label'],
+                    'products' => array_values(array_map(
+                        fn (array $product): array => [
+                            'value' => $product['value'],
+                            'label' => $product['label'],
+                            'types' => array_values($product['types']),
+                            ...($includeSizes ? ['sizes' => array_values($product['sizes'])] : []),
+                        ],
+                        $category['products'],
+                    )),
+                ],
+                $categories,
+            )),
+        ];
+    }
+
+    /** @return list<string> */
+    private function relations(): array
+    {
+        return [
+            'category',
+            'itemAttributes.attribute.options',
+            'variants.definitions.itemAttribute.attribute.options',
+            'variants.eventDates',
+            'variants.eventDate',
+        ];
+    }
+
+    /**
+     * @return list<array{
+     *     value: string,
+     *     label: string,
+     *     types: list<array{value: string, label: string}>,
+     *     sizes: list<array{value: string, label: string}>
+     * }>
+     */
+    private function products(CatalogItem $item, string $productCode, ?string $typeCode, ?string $sizeCode): array
+    {
+        if ($productCode === self::PRODUCT) {
+            return [[
+                'value' => $item->slug,
+                'label' => $item->nombre,
+                'types' => $this->types($item, $typeCode, $sizeCode),
+                'sizes' => $this->types($item, $sizeCode),
+            ]];
+        }
+
+        $products = [];
+
+        foreach ($item->variants as $variant) {
+            foreach ($this->variantOptions($variant, $productCode) as $productOption) {
+                $productValue = $productOption['value'];
+                $products[$productValue] ??= [
+                    'value' => $productValue,
+                    'label' => $this->optionLabel($productOption['label'], $productCode),
+                    'types' => [],
+                    'sizes' => [],
+                ];
+
+                foreach ($this->variantOptions($variant, $typeCode) as $typeOption) {
+                    $this->mergeTypeOption(
+                        $products[$productValue]['types'],
+                        $typeOption,
+                        $variant,
+                        $sizeCode,
+                    );
+                }
+
+                foreach ($this->variantOptions($variant, $sizeCode) as $sizeOption) {
+                    $products[$productValue]['sizes'][$sizeOption['value']] = $sizeOption;
+                }
+            }
+        }
+
+        return array_values(array_map(
+            fn (array $product): array => [
+                'value' => $product['value'],
+                'label' => $product['label'],
+                'types' => array_values($product['types']),
+                'sizes' => array_values($product['sizes']),
+            ],
+            $products,
+        ));
+    }
+
+    /** @return list<array<string, mixed>> */
+    private function types(CatalogItem $item, ?string $typeCode, ?string $sizeCode = null): array
+    {
+        $types = [];
+
+        foreach ($item->variants as $variant) {
+            foreach ($this->variantOptions($variant, $typeCode) as $typeOption) {
+                $this->mergeTypeOption($types, $typeOption, $variant, $sizeCode);
+            }
+        }
+
+        return array_values(array_map(function (array $type) use ($sizeCode): array {
+            if ($sizeCode !== null) {
+                $type['sizes'] = array_values($type['sizes']);
+            }
+
+            return $type;
+        }, $types));
+    }
+
+    /**
+     * @param  array<string, array<string, mixed>>  $types
+     * @param  array{value: string, label: string}  $typeOption
+     */
+    private function mergeTypeOption(
+        array &$types,
+        array $typeOption,
+        Variant $variant,
+        ?string $sizeCode,
+    ): void {
+        $typeValue = $typeOption['value'];
+        $types[$typeValue] ??= [
+            ...$typeOption,
+            ...($sizeCode !== null ? ['sizes' => []] : []),
+        ];
+
+        foreach ($this->variantOptions($variant, $sizeCode) as $sizeOption) {
+            $types[$typeValue]['sizes'][$sizeOption['value']] = $sizeOption;
+        }
+    }
+
+    /** @return list<array{value: string, label: string}> */
+    private function variantOptions(Variant $variant, ?string $attributeCode): array
+    {
+        if ($attributeCode === null) {
+            return [];
+        }
+
+        $selection = $variant->selectionOptions($variant->catalogItem->itemAttributes)
+            ->get($attributeCode);
+
+        if ($selection === null) {
+            return [];
+        }
+
+        return array_is_list($selection) ? $selection : [$selection];
+    }
+
+    private function optionLabel(string $label, string $attributeCode): string
+    {
+        if ($attributeCode !== 'event_date') {
+            return $label;
+        }
+
+        [$day, $month] = array_pad(explode('/', $label), 2, null);
+
+        return $day !== null && $month !== null ? "{$day}/{$month}" : $label;
+    }
+}

app/Domains/Forms/documentacion/README.md

@@ -9,6 +9,7 @@ Provee catálogos y opciones auxiliares para construir formularios del panel adm
 - `EventFormService`: devuelve redes sociales disponibles y las URL configuradas para el tenant.
 - `SaleFormService`: expone los estados admitidos para compras con sus etiquetas de presentación.
 - `StaffFormService`: lista categorías raíz que pueden asignarse al personal del tenant.
+- `TicketFormService`: expone estados y opciones anidadas de categoría, producto y tipo para los tickets de Fiesta Fútbol Infantil.
 
 Cada servicio tiene un controlador invocable y un `JsonResource` específico. `SocialMediaOptionResource` representa las opciones de redes sociales.
 
@@ -19,6 +20,7 @@ Bajo `/v1/adminapp/forms`, con `auth:sanctum` y `adminapp.tenant`:
 - `GET /event`.
 - `GET /sale`.
 - `GET /staff`.
+- `GET /fiesta-futbol-infantil/ticket`: estados y jerarquía categoría → producto → tipo para filtros de tickets.
 - `GET /fiesta-futbol-infantil/merchandise`: opciones de color y talle del tenant para merchandising.
 
 ## Dependencias

app/Domains/Forms/routes/adminapp.php

@@ -5,6 +5,8 @@ use App\Domains\Forms\Controllers\AdminApp\FoodFormController;
 use App\Domains\Forms\Controllers\AdminApp\MerchandiseFormController;
 use App\Domains\Forms\Controllers\AdminApp\SaleFormController;
 use App\Domains\Forms\Controllers\AdminApp\StaffFormController;
+use App\Domains\Forms\Controllers\AdminApp\TicketFilterFormController;
+use App\Domains\Forms\Controllers\AdminApp\TicketFormController;
 use Illuminate\Support\Facades\Route;
 
 Route::prefix('v1/adminapp/forms')
@@ -13,6 +15,13 @@ Route::prefix('v1/adminapp/forms')
         Route::get('event', EventFormController::class);
         Route::get('sale', SaleFormController::class);
         Route::get('staff', StaffFormController::class);
+        Route::get('tickets-filter', TicketFilterFormController::class)
+            ->middleware('tenant.menu:adminapp.tickets')
+            ->name('adminapp.forms.tickets-filter');
+        Route::get(
+            'fiesta-futbol-infantil/ticket',
+            TicketFormController::class
+        );
         Route::get(
             'fiesta-futbol-infantil/merchandise',
             MerchandiseFormController::class

app/Domains/Integration/Controllers/ClientIntegrationController.php

@@ -4,8 +4,9 @@ namespace App\Domains\Integration\Controllers;
 
 use App\Domains\Client\Models\Client;
 use App\Domains\Integration\Models\Integration;
-use App\Domains\Integration\Requests\StoreClientIntegrationRequest;
+use App\Domains\Integration\Requests\ConfigureIntegrationRequest;
 use App\Domains\Integration\Services\ClientIntegrationService;
+use App\Domains\Integration\Services\IntegrationAssociationService;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\JsonResponse;
 
@@ -35,7 +36,7 @@ class ClientIntegrationController extends Controller
     }
 
     public function store(
-        StoreClientIntegrationRequest $request,
+        ConfigureIntegrationRequest $request,
         Client $client,
         string $integrationCode,
     ): JsonResponse {
@@ -61,4 +62,11 @@ class ClientIntegrationController extends Controller
             ], 400);
         }
     }
+
+    public function destroy(Client $client, string $integrationCode, IntegrationAssociationService $service)
+    {
+        $service->detach($client, $integrationCode);
+
+        return response()->noContent();
+    }
 }

app/Domains/Integration/Controllers/IntegrationController.php

@@ -0,0 +1,43 @@
+<?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)
+    {
+        abort_if($integration->instances()->exists(), 409, 'Delete the integration instances first.');
+        $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/Controllers/WebsiteTypeIntegrationController.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Domains\Integration\Controllers;
+
+use App\Domains\Integration\Models\Integration;
+use App\Domains\Integration\Requests\ConfigureIntegrationRequest;
+use App\Domains\Integration\Resources\IntegrationAssociationResource;
+use App\Domains\Integration\Services\IntegrationAssociationService;
+use App\Domains\Tenant\Models\WebsiteType;
+use App\Http\Controllers\Controller;
+
+class WebsiteTypeIntegrationController extends Controller
+{
+    public function __construct(private readonly IntegrationAssociationService $service) {}
+
+    public function index(WebsiteType $websiteType)
+    {
+        return IntegrationAssociationResource::collection($websiteType->integrations()->with('integrationInstance')->get());
+    }
+
+    public function show(WebsiteType $websiteType, string $integrationCode)
+    {
+        return new IntegrationAssociationResource($websiteType->integrations()->with('integrationInstance')->where('integration_code', $integrationCode)->firstOrFail());
+    }
+
+    public function store(ConfigureIntegrationRequest $request, WebsiteType $websiteType, string $integrationCode)
+    {
+        $integration = Integration::query()->where('integration_code', $integrationCode)->firstOrFail();
+
+        return new IntegrationAssociationResource($this->service->configure(
+            $websiteType,
+            $integration,
+            $request->validated('integration_data'),
+        ));
+    }
+
+    public function destroy(WebsiteType $websiteType, string $integrationCode)
+    {
+        $this->service->detach($websiteType, $integrationCode);
+
+        return response()->noContent();
+    }
+}

app/Domains/Integration/Models/ClientIntegration.php

@@ -3,22 +3,15 @@
 namespace App\Domains\Integration\Models;
 
 use App\Domains\Client\Models\Client;
-use App\Domains\Integration\Casts\EncryptedIntegrationData;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 class ClientIntegration extends Model
 {
-    protected $hidden = ['integration_data'];
-
     protected $fillable = [
         'client_id',
         'integration_code',
-        'integration_data',
-    ];
-
-    protected $casts = [
-        'integration_data' => EncryptedIntegrationData::class,
+        'integration_instance_id',
     ];
 
     /** @return BelongsTo<Client, $this> */
@@ -32,4 +25,10 @@ class ClientIntegration extends Model
     {
         return $this->belongsTo(Integration::class, 'integration_code', 'integration_code');
     }
+
+    /** @return BelongsTo<IntegrationInstance, $this> */
+    public function integrationInstance(): BelongsTo
+    {
+        return $this->belongsTo(IntegrationInstance::class);
+    }
 }

app/Domains/Integration/Models/Integration.php

@@ -3,6 +3,7 @@
 namespace App\Domains\Integration\Models;
 
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 class Integration extends Model
 {
@@ -13,16 +14,29 @@ class Integration extends Model
         'name',
         'url',
         'integration_data_schema',
-        'requires_client_configuration',
+        'requires_configuration',
     ];
 
     protected $casts = [
         'integration_data_schema' => 'array',
-        'requires_client_configuration' => 'boolean',
+        'requires_configuration' => 'boolean',
     ];
 
-    public function clientIntegrations()
+    /** @return HasMany<IntegrationInstance, $this> */
+    public function instances(): HasMany
+    {
+        return $this->hasMany(IntegrationInstance::class, 'integration_code', 'integration_code');
+    }
+
+    /** @return HasMany<ClientIntegration, $this> */
+    public function clientIntegrations(): HasMany
     {
         return $this->hasMany(ClientIntegration::class, 'integration_code', 'integration_code');
     }
+
+    /** @return HasMany<WebsiteTypeIntegration, $this> */
+    public function websiteTypeIntegrations(): HasMany
+    {
+        return $this->hasMany(WebsiteTypeIntegration::class, 'integration_code', 'integration_code');
+    }
 }

app/Domains/Integration/Models/IntegrationInstance.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Domains\Integration\Models;
+
+use App\Domains\Integration\Casts\EncryptedIntegrationData;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class IntegrationInstance extends Model
+{
+    // The ciphertext changes whenever credentials are saved, so old tokens cannot be reused.
+    public function tokenCacheKey(): string
+    {
+        return 'integration_token:instance:'.$this->id.':'.hash('sha256', (string) $this->getRawOriginal('integration_data'));
+    }
+
+    protected $fillable = ['integration_code', 'name', 'integration_data'];
+
+    protected $hidden = ['integration_data'];
+
+    protected $casts = ['integration_data' => EncryptedIntegrationData::class];
+
+    /** @return BelongsTo<Integration, $this> */
+    public function integration(): BelongsTo
+    {
+        return $this->belongsTo(Integration::class, 'integration_code', 'integration_code');
+    }
+
+    /** @return HasMany<ClientIntegration, $this> */
+    public function clientIntegrations(): HasMany
+    {
+        return $this->hasMany(ClientIntegration::class);
+    }
+
+    /** @return HasMany<WebsiteTypeIntegration, $this> */
+    public function websiteTypeIntegrations(): HasMany
+    {
+        return $this->hasMany(WebsiteTypeIntegration::class);
+    }
+}

app/Domains/Integration/Models/WebsiteTypeIntegration.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Domains\Integration\Models;
+
+use App\Domains\Tenant\Models\WebsiteType;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class WebsiteTypeIntegration extends Model
+{
+    protected $fillable = ['website_type_code', 'integration_code', 'integration_instance_id'];
+
+    /** @return BelongsTo<WebsiteType, $this> */
+    public function websiteType(): BelongsTo
+    {
+        return $this->belongsTo(WebsiteType::class, 'website_type_code', 'codigo');
+    }
+
+    /** @return BelongsTo<Integration, $this> */
+    public function integration(): BelongsTo
+    {
+        return $this->belongsTo(Integration::class, 'integration_code', 'integration_code');
+    }
+
+    /** @return BelongsTo<IntegrationInstance, $this> */
+    public function integrationInstance(): BelongsTo
+    {
+        return $this->belongsTo(IntegrationInstance::class);
+    }
+}

app/Domains/Integration/Policies/IntegrationPolicy.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Domains\Integration\Policies;
+
+use App\Domains\Auth\Models\User;
+use App\Domains\Authorization\Enums\RoleCode;
+
+class IntegrationPolicy
+{
+    public function manage(User $user): bool
+    {
+        return $user->rol_codigo === RoleCode::Admin->value;
+    }
+}

app/Domains/Integration/Requests/ConfigureIntegrationRequest.php

@@ -6,20 +6,19 @@ use App\Domains\Integration\Models\Integration;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\ValidationException;
 
-class StoreClientIntegrationRequest extends FormRequest
+class ConfigureIntegrationRequest extends FormRequest
 {
     protected ?Integration $integrationModel = null;
 
     public function authorize(): bool
     {
-        return true;
+        return $this->user()?->can('manage', Integration::class) ?? false;
     }
 
     protected function prepareForValidation(): void
     {
-        $integrationCode = $this->route('integration_code');
         $this->integrationModel = Integration::query()
-            ->where('integration_code', $integrationCode)
+            ->where('integration_code', $this->route('integration_code'))
             ->first();
 
         if (! $this->integrationModel) {
@@ -31,7 +30,7 @@ class StoreClientIntegrationRequest extends FormRequest
 
     public function rules(): array
     {
-        $rules = [];
+        $rules = ['integration_data' => ['present', 'array']];
 
         foreach ($this->integrationModel?->integration_data_schema ?? [] as $field => $rule) {
             $rules['integration_data.'.$field] = $rule;

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_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;
+use Illuminate\Validation\Rule;
+
+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_configuration' => ['sometimes', 'boolean'],
+            'integration_code' => ['sometimes', 'required', 'string', Rule::in([$integration->integration_code])],
+        ];
+    }
+}

app/Domains/Integration/Resources/IntegrationAssociationResource.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domains\Integration\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IntegrationAssociationResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'client_id' => $this->when(isset($this->client_id), $this->client_id),
+            'website_type_code' => $this->when(isset($this->website_type_code), $this->website_type_code),
+            'integration_code' => $this->integration_code,
+            'integration_instance_id' => $this->integration_instance_id,
+            'integration_instance' => new IntegrationInstanceResource($this->whenLoaded('integrationInstance')),
+        ];
+    }
+}

app/Domains/Integration/Resources/IntegrationInstanceResource.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Domains\Integration\Resources;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IntegrationInstanceResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->id,
+            'integration_code' => $this->integration_code,
+            'name' => $this->name,
+            'created_at' => $this->created_at,
+            'updated_at' => $this->updated_at,
+        ];
+    }
+}

app/Domains/Integration/Services/BaseIntegrationService.php

@@ -5,6 +5,8 @@ namespace App\Domains\Integration\Services;
 use App\Domains\Client\Models\Client;
 use App\Domains\Integration\Models\ClientIntegration;
 use App\Domains\Integration\Models\Integration;
+use App\Domains\Integration\Models\IntegrationInstance;
+use App\Domains\Integration\Models\WebsiteTypeIntegration;
 use App\Domains\Tenant\Models\Tenant;
 use Exception;
 use Illuminate\Http\Client\PendingRequest;
@@ -32,9 +34,9 @@ abstract class BaseIntegrationService
     protected ?Integration $integration = null;
 
     /**
-     * The client-owned integration configuration.
+     * The effective integration instance.
      */
-    protected ?ClientIntegration $clientIntegration = null;
+    protected ?IntegrationInstance $integrationInstance = null;
 
     /**
      * Set the integration code.
@@ -85,7 +87,7 @@ abstract class BaseIntegrationService
     }
 
     /**
-     * Load the integration definition and its client-owned configuration.
+     * Load the integration definition and its effective instance configuration.
      *
      * @throws Exception
      */
@@ -95,6 +97,7 @@ abstract class BaseIntegrationService
             throw new Exception('Integration code is not set.');
         }
 
+        $this->integrationInstance = null;
         $this->integration = Integration::where('integration_code', $this->integrationCode)->first();
         if (! $this->integration) {
             throw new Exception("Integration with code '{$this->integrationCode}' not found.");
@@ -104,11 +107,18 @@ abstract class BaseIntegrationService
             throw new Exception('Client context is not set.');
         }
 
-        $this->clientIntegration = ClientIntegration::where('client_id', $this->clientContext->id)
+        $this->integrationInstance = ClientIntegration::with('integrationInstance')->where('client_id', $this->clientContext->id)
             ->where('integration_code', $this->integrationCode)
-            ->first();
+            ->first()?->integrationInstance;
 
-        if (! $this->clientIntegration && $this->integration->requires_client_configuration) {
+        if (! $this->integrationInstance && $this->tenant?->website_type_code) {
+            $this->integrationInstance = WebsiteTypeIntegration::with('integrationInstance')
+                ->where('website_type_code', $this->tenant->website_type_code)
+                ->where('integration_code', $this->integrationCode)
+                ->first()?->integrationInstance;
+        }
+
+        if (! $this->integrationInstance && $this->integration->requires_configuration) {
             throw new Exception("Client '{$this->clientContext->code}' does not have integration '{$this->integrationCode}' configured.");
         }
     }
@@ -131,15 +141,15 @@ abstract class BaseIntegrationService
     }
 
     /**
-     * Get an integration setting from the client-owned configuration.
+     * Get an integration setting from the effective instance configuration.
      */
     protected function getIntegrationSetting(string $key, mixed $default = null): mixed
     {
-        if (! $this->clientIntegration || ! $this->clientIntegration->integration_data) {
+        if (! $this->integrationInstance || ! $this->integrationInstance->integration_data) {
             return $default;
         }
 
-        return $this->clientIntegration->integration_data[$key] ?? $default;
+        return $this->integrationInstance->integration_data[$key] ?? $default;
     }
 
     /**

app/Domains/Integration/Services/ClientIntegrationService.php

@@ -13,6 +13,7 @@ class ClientIntegrationService
     public function getClientIntegration(Client $client, string $integrationCode): ?ClientIntegration
     {
         return $client->integrations()
+            ->with(['integration', 'integrationInstance'])
             ->where('integration_code', $integrationCode)
             ->first();
     }
@@ -20,7 +21,7 @@ class ClientIntegrationService
     /** @return Collection<int, ClientIntegration> */
     public function getAllForClient(Client $client): Collection
     {
-        return $client->integrations()->with('integration')->get();
+        return $client->integrations()->with(['integration', 'integrationInstance'])->get();
     }
 
     public function updateOrCreateIntegration(
@@ -29,13 +30,7 @@ class ClientIntegrationService
         array $data,
     ): ClientIntegration {
         return DB::transaction(function () use ($client, $integration, $data): ClientIntegration {
-            $clientIntegration = ClientIntegration::query()->updateOrCreate(
-                [
-                    'client_id' => $client->id,
-                    'integration_code' => $integration->integration_code,
-                ],
-                ['integration_data' => $data],
-            );
+            $clientIntegration = app(IntegrationAssociationService::class)->configure($client, $integration, $data);
 
             $service = $this->resolveService($integration->integration_code);
             $service?->forClient($client)->onSetup();

app/Domains/Integration/Services/IntegrationAssociationService.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Domains\Integration\Services;
+
+use App\Domains\Client\Models\Client;
+use App\Domains\Integration\Models\ClientIntegration;
+use App\Domains\Integration\Models\Integration;
+use App\Domains\Integration\Models\IntegrationInstance;
+use App\Domains\Integration\Models\WebsiteTypeIntegration;
+use App\Domains\Tenant\Models\WebsiteType;
+use Illuminate\Support\Facades\DB;
+
+class IntegrationAssociationService
+{
+    public function configure(Client|WebsiteType $owner, Integration $integration, array $integrationData): ClientIntegration|WebsiteTypeIntegration
+    {
+        return DB::transaction(function () use ($owner, $integration, $integrationData): ClientIntegration|WebsiteTypeIntegration {
+            $instance = IntegrationInstance::create([
+                'integration_code' => $integration->integration_code,
+                'name' => $integration->name.' / '.$this->ownerName($owner),
+                'integration_data' => $integrationData,
+            ]);
+
+            return $this->associate($owner, $integration->integration_code, $instance);
+        });
+    }
+
+    public function associate(Client|WebsiteType $owner, string $code, IntegrationInstance $instance): ClientIntegration|WebsiteTypeIntegration
+    {
+        return DB::transaction(function () use ($owner, $code, $instance): ClientIntegration|WebsiteTypeIntegration {
+            $association = $owner->integrations()
+                ->where('integration_code', $code)
+                ->lockForUpdate()
+                ->first();
+            $previousInstanceId = $association?->integration_instance_id;
+
+            $instanceIds = array_values(array_unique(array_filter([
+                $previousInstanceId,
+                $instance->id,
+            ])));
+            sort($instanceIds);
+
+            $instances = IntegrationInstance::query()
+                ->whereKey($instanceIds)
+                ->orderBy('id')
+                ->lockForUpdate()
+                ->get()
+                ->keyBy('id');
+            $instance = $instances->get($instance->id) ?? IntegrationInstance::query()->findOrFail($instance->id);
+            abort_unless($instance->integration_code === $code, 422, 'The instance belongs to another integration.');
+
+            $association = $owner->integrations()->updateOrCreate(
+                ['integration_code' => $code],
+                ['integration_instance_id' => $instance->id],
+            );
+
+            if ($previousInstanceId && $previousInstanceId !== $instance->id) {
+                $this->deleteIfUnused($previousInstanceId);
+            }
+
+            return $association->load('integrationInstance');
+        });
+    }
+
+    public function detach(Client|WebsiteType $owner, string $code): void
+    {
+        DB::transaction(function () use ($owner, $code): void {
+            $association = $owner->integrations()
+                ->where('integration_code', $code)
+                ->lockForUpdate()
+                ->first();
+
+            if (! $association) {
+                return;
+            }
+
+            $instanceId = $association->integration_instance_id;
+            $association->delete();
+            $this->deleteIfUnused($instanceId);
+        });
+    }
+
+    private function deleteIfUnused(int $instanceId): void
+    {
+        $instance = IntegrationInstance::query()->lockForUpdate()->find($instanceId);
+
+        if ($instance
+            && ! $instance->clientIntegrations()->exists()
+            && ! $instance->websiteTypeIntegrations()->exists()) {
+            $instance->delete();
+        }
+    }
+
+    private function ownerName(Client|WebsiteType $owner): string
+    {
+        return $owner instanceof Client ? $owner->name : $owner->nombre;
+    }
+}

app/Domains/Integration/Services/IntegrationInstanceService.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Domains\Integration\Services;
+
+use App\Domains\Integration\Models\IntegrationInstance;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
+
+class IntegrationInstanceService
+{
+    public function create(array $data): IntegrationInstance
+    {
+        return IntegrationInstance::create($data);
+    }
+
+    public function update(IntegrationInstance $instance, array $data): IntegrationInstance
+    {
+        return DB::transaction(function () use ($instance, $data): IntegrationInstance {
+            $instance = IntegrationInstance::query()->lockForUpdate()->findOrFail($instance->id);
+            $cacheKey = $instance->tokenCacheKey();
+            $instance->update($data);
+            if (array_key_exists('integration_data', $data)) {
+                DB::afterCommit(fn () => Cache::forget($cacheKey));
+            }
+
+            return $instance;
+        });
+    }
+
+    public function delete(IntegrationInstance $instance): void
+    {
+        DB::transaction(function () use ($instance): void {
+            $instance = IntegrationInstance::query()->lockForUpdate()->findOrFail($instance->id);
+            abort_if($instance->clientIntegrations()->exists() || $instance->websiteTypeIntegrations()->exists(), 409, 'Unlink the instance before deleting it.');
+            $cacheKey = $instance->tokenCacheKey();
+            $instance->delete();
+            DB::afterCommit(fn () => Cache::forget($cacheKey));
+        });
+    }
+}

app/Domains/Integration/Services/MailService.php

@@ -29,7 +29,7 @@ class MailService extends BaseIntegrationService
 
     private ?Mailer $mailer = null;
 
-    private bool $usesClientMailer = false;
+    private bool $usesInstanceMailer = false;
 
     public function __construct(?MailFactory $mailFactory = null)
     {
@@ -40,12 +40,12 @@ class MailService extends BaseIntegrationService
     {
         parent::forTenant($tenantCode);
 
-        if ($this->clientIntegration) {
+        if ($this->integrationInstance) {
             $this->mailer = $this->resolveMailer();
-            $this->usesClientMailer = true;
+            $this->usesInstanceMailer = true;
         } else {
             $this->mailer = $this->mailFactory->mailer();
-            $this->usesClientMailer = false;
+            $this->usesInstanceMailer = false;
         }
 
         return $this;
@@ -56,12 +56,12 @@ class MailService extends BaseIntegrationService
         parent::forClient($client);
         $this->tenant = $this->clientContext?->tenants()->first();
 
-        if ($this->clientIntegration) {
+        if ($this->integrationInstance) {
             $this->mailer = $this->resolveMailer();
-            $this->usesClientMailer = true;
+            $this->usesInstanceMailer = true;
         } else {
             $this->mailer = $this->mailFactory->mailer();
-            $this->usesClientMailer = false;
+            $this->usesInstanceMailer = false;
         }
 
         return $this;
@@ -122,8 +122,8 @@ class MailService extends BaseIntegrationService
 
     public function mailerName(): string
     {
-        return $this->usesClientMailer
-            ? 'client-smtp'
+        return $this->usesInstanceMailer
+            ? 'integration-smtp'
             : (string) config('mail.default');
     }
 
@@ -187,7 +187,7 @@ class MailService extends BaseIntegrationService
 
     private function resolveMailer(): Mailer
     {
-        $data = $this->clientIntegration?->integration_data;
+        $data = $this->integrationInstance?->integration_data;
 
         if (! is_array($data)) {
             throw new InvalidArgumentException('La configuración SMTP del cliente no es válida.');
@@ -205,7 +205,7 @@ class MailService extends BaseIntegrationService
         }
 
         $mailer = $this->mailFactory->build([
-            'name' => 'client-smtp-'.$this->clientContext?->id,
+            'name' => 'integration-smtp-'.$this->integrationInstance?->id,
             'transport' => 'smtp',
             'scheme' => $data['MAIL_SCHEME'] ?? null,
             'host' => $data['MAIL_HOST'],

app/Domains/Integration/Services/TelepagosIntegrationService.php

@@ -45,11 +45,11 @@ class TelepagosIntegrationService extends BaseIntegrationService
      */
     public function getToken(): string
     {
-        if (! $this->clientIntegration || ! $this->clientContext) {
+        if (! $this->integrationInstance) {
             throw new Exception('Client integration is not loaded. Call forTenant() or forClient() first.');
         }
 
-        $cacheKey = "integration_token:{$this->clientContext->id}:{$this->integrationCode}";
+        $cacheKey = $this->integrationInstance->tokenCacheKey();
 
         $token = Cache::get($cacheKey);
 
@@ -94,7 +94,7 @@ class TelepagosIntegrationService extends BaseIntegrationService
         // Calculate TTL and subtract a buffer of 60 seconds
         $ttlSeconds = max(1, $expiresAt->diffInSeconds(now()) - 60);
 
-        $cacheKey = "integration_token:{$this->clientContext->id}:{$this->integrationCode}";
+        $cacheKey = $this->integrationInstance->tokenCacheKey();
         Cache::put($cacheKey, $token, $ttlSeconds);
 
         return $token;
@@ -220,11 +220,11 @@ class TelepagosIntegrationService extends BaseIntegrationService
      */
     public function clearToken(): void
     {
-        if (! $this->clientContext) {
+        if (! $this->integrationInstance) {
             return;
         }
 
-        $cacheKey = "integration_token:{$this->clientContext->id}:{$this->integrationCode}";
+        $cacheKey = $this->integrationInstance->tokenCacheKey();
         Cache::forget($cacheKey);
     }
 

app/Domains/Integration/Services/TelepagosWebhookService.php

@@ -0,0 +1,333 @@
+<?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 App\Domains\Purchase\Services\DniDistanceService;
+use Exception;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class TelepagosWebhookService
+{
+    public function __construct(
+        private readonly CheckoutService $checkoutService,
+        private readonly DniDistanceService $dniDistance,
+    ) {}
+
+    /**
+     * 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,
+                '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');
+                $eligiblePurchases = Purchase::query()
+                    ->whereIn('tenant_codigo', $tenantCodes)
+                    ->whereIn('status', [
+                        Purchase::STATUS_CREATED,
+                        Purchase::STATUS_PENDING_PAYMENT,
+                        Purchase::STATUS_IN_REVIEW,
+                    ])
+                    ->where('payment_method', 'transfer');
+
+                $purchases = (clone $eligiblePurchases)
+                    ->where('total', $amount)
+                    ->latest()
+                    ->get()
+                    ->filter(fn (Purchase $purchase): bool => $purchase->transfer_payer_dni !== null
+                        && $this->dniDistance->distance($dni, $purchase->transfer_payer_dni) === 0)
+                    ->values();
+
+                $compra = $purchases->count() === 1 ? $purchases->first() : null;
+
+                if (! $compra) {
+                    $candidatePurchases = $this->findTransferCandidates(
+                        $eligiblePurchases,
+                        $dni,
+                        $amount,
+                    );
+                    if ($candidatePurchases->isNotEmpty()) {
+                        $payment = $this->storeTransferCandidates(
+                            $paymentData,
+                            $candidatePurchases,
+                            $dni,
+                            $amount,
+                        );
+
+                        Log::channel('telepagos')->info('Telepagos webhook: Transfer payment candidates found.', [
+                            'client_code' => $client->code,
+                            'cashin_id' => $cashinId,
+                            'telepagos_payment_id' => $payment->id,
+                            'amount' => $amount,
+                            'candidate_count' => $payment->candidates->count(),
+                            'candidates' => $payment->candidates
+                                ->map(fn ($candidate): array => [
+                                    'purchase_id' => $candidate->compra_id,
+                                    'match_reason' => $candidate->match_reason,
+                                    'dni_distance' => $candidate->dni_distance,
+                                    'amount_difference' => $candidate->amount_difference,
+                                    'confidence' => $candidate->confidence,
+                                ])
+                                ->all(),
+                        ]);
+                    }
+
+                    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, '.', '');
+    }
+
+    /**
+     * @param  Builder<Purchase>  $eligiblePurchases
+     * @return Collection<int, Purchase>
+     */
+    private function findTransferCandidates(Builder $eligiblePurchases, string $dni, string $amount): Collection
+    {
+        $tolerancePercentage = max(
+            0,
+            (float) config('purchase.transfer_candidate_amount_tolerance_percentage', 5),
+        );
+        $numericAmount = (float) $amount;
+        $tolerance = $numericAmount * ($tolerancePercentage / 100);
+        $minimumAmount = $this->normalizeAmount(max(0, $numericAmount - $tolerance));
+        $maximumAmount = $this->normalizeAmount($numericAmount + $tolerance);
+
+        return (clone $eligiblePurchases)
+            ->whereBetween('total', [$minimumAmount, $maximumAmount])
+            ->latest()
+            ->get()
+            ->filter(function (Purchase $purchase) use ($dni, $amount): bool {
+                if ($purchase->transfer_payer_dni === null) {
+                    return false;
+                }
+
+                $purchaseAmount = $this->normalizeAmount($purchase->total);
+                $distance = $this->dniDistance->distance(
+                    $dni,
+                    (string) $purchase->transfer_payer_dni,
+                );
+
+                return $distance === 0
+                    || ($purchaseAmount === $amount && $distance <= 2);
+            })
+            ->values();
+    }
+
+    /**
+     * @param  array<string, mixed>  $paymentData
+     * @param  Collection<int, Purchase>  $candidatePurchases
+     */
+    private function storeTransferCandidates(
+        array $paymentData,
+        Collection $candidatePurchases,
+        string $dni,
+        string $amount,
+    ): TelepagosPayment {
+        return DB::transaction(function () use ($paymentData, $candidatePurchases, $dni, $amount): TelepagosPayment {
+            $payment = TelepagosPayment::create($paymentData);
+
+            $payment->candidates()->createMany(
+                $candidatePurchases
+                    ->map(function (Purchase $purchase) use ($dni, $amount): array {
+                        $purchaseAmount = $this->normalizeAmount($purchase->total);
+                        $dniDistance = $this->dniDistance->distance(
+                            $dni,
+                            (string) $purchase->transfer_payer_dni,
+                        );
+                        $dniMatches = $dniDistance === 0;
+                        $amountMatches = $purchaseAmount === $amount;
+
+                        return [
+                            'compra_id' => $purchase->id,
+                            'dni_matches' => $dniMatches,
+                            'dni_distance' => $dniDistance,
+                            'payment_dni' => $dni,
+                            'purchase_dni' => $purchase->transfer_payer_dni,
+                            'amount_matches' => $amountMatches,
+                            'payment_amount' => $amount,
+                            'purchase_amount' => $purchaseAmount,
+                            'amount_difference' => $this->normalizeAmount(
+                                abs((float) $purchaseAmount - (float) $amount),
+                            ),
+                            'match_reason' => $amountMatches
+                                ? ($dniMatches ? 'ambiguous_exact_match' : 'exact_amount_near_dni')
+                                : 'exact_dni_near_amount',
+                            'confidence' => $amountMatches
+                                ? ($dniMatches ? 'exact' : 'medium')
+                                : 'high',
+                        ];
+                    })
+                    ->all(),
+            );
+
+            return $payment->load('candidates');
+        });
+    }
+}

app/Domains/Integration/documentacion/README.md

@@ -1,30 +1,48 @@
 # Dominio Integration
 
-## Propósito
+## Modelo
 
-Gestiona integraciones externas disponibles y su configuración por cliente. Un cliente puede agrupar múltiples tenants que comparten las mismas credenciales. Incluye correo y pagos mediante Telepagos.
+- `Integration`: catálogo, URL base, `integration_data_schema` y `requires_configuration`.
+- `IntegrationInstance`: configuración interna concreta con nombre. `integration_data` se cifra con `EncryptedIntegrationData`, se almacena en `longText` y nunca se devuelve en la API.
+- `ClientIntegration` y `WebsiteTypeIntegration`: asociaciones a instancias. La clave compuesta verifica el código de la instancia y la unicidad permite una instancia por integración y propietario.
 
-## Modelo y seguridad
+Las instancias no se administran directamente por HTTP. Cada configuración enviada desde un cliente o tipo de sitio crea una instancia interna nueva y reemplaza únicamente la asociación de ese propietario. Al reemplazar o desvincular una instancia, esta se elimina si ya no tiene asociaciones con ningún cliente ni tipo de sitio; las instancias compartidas se conservan mientras tengan al menos una asociación.
 
-- `Integration`: definición global de una integración.
-- `ClientIntegration`: configuración y credenciales de una integración para un cliente.
-- `EncryptedIntegrationData`: cast que protege los datos sensibles persistidos.
-- `ClientIntegrationService`: consulta y configura integraciones del cliente.
+## Resolución
 
-## Servicios externos
+`BaseIntegrationService::forTenant()` busca primero la asociación del cliente y después la del tipo de sitio del tenant. Selecciona una configuración completa, sin mezclar credenciales entre niveles. Si una configuración está presente pero es inválida, produce un error en vez de recurrir a otra instancia.
 
-- `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.
+`forClient()` usa únicamente la asociación del cliente: sin un tenant concreto no se elige un tipo de sitio. Si no existe una instancia y `requires_configuration` es verdadero, se genera un error. Para correo opcional, `MailService` usa el mailer global si no encuentra una instancia; cuando la encuentra, construye un transporte SMTP aislado identificado como `integration-smtp`.
 
-## Endpoints
+Telepagos utiliza una clave de caché basada en el ID de instancia y una huella del texto cifrado. Volver a configurar el servicio con `forClient()` o `forTenant()` carga la configuración actual.
 
-- Consulta y configuración por cliente bajo `/clients/{client}/integrations`.
+## Administración
 
-## Logging de Telepagos
+Todas estas rutas llevan el prefijo `/api`, requieren `auth:sanctum` y el rol global `admin` mediante `IntegrationPolicy`. Los roles `adminapp`, `scanner` y `user` no administran configuraciones.
 
-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.
+| Método | Ruta | Operación |
+| --- | --- | --- |
+| GET | `/clients/{client}/integrations[/{integration_code}]` | Consultar asociaciones directas. |
+| PUT | `/clients/{client}/integrations/{integration_code}` | Configurar: crea una instancia interna nueva y reemplaza solo la asociación del cliente. Ejecuta el hook de configuración existente. |
+| DELETE | `/clients/{client}/integrations/{integration_code}` | Desvincular. |
+| GET | `/website-types/{codigo}/integrations[/{integration_code}]` | Consultar asociaciones del tipo de sitio. |
+| PUT | `/website-types/{codigo}/integrations/{integration_code}` | Configurar: crea una instancia interna nueva y reemplaza solo la asociación del tipo de sitio. |
+| DELETE | `/website-types/{codigo}/integrations/{integration_code}` | Desvincular. |
 
-## Dependencias y reglas
+Los dos `PUT` reciben `integration_data`, un objeto completo validado según el esquema de la integración. La integración debe existir previamente en el catálogo interno. No hay endpoints públicos para administrar el catálogo ni las instancias directamente.
 
-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.
+Las respuestas y consultas incluyen metadatos de `integration_instance`, pero nunca sus credenciales. La configuración del cliente conserva su mensaje de respuesta histórico; la del tipo de sitio usa un resource con envoltorio `data`.
+
+## Webhooks y contexto operativo
+
+`POST /webhooks/telepagos/{client}` conserva su contrato público con el proveedor y la validación de pertenencia de las compras al cliente. Como no recibe un tenant, requiere una asociación directa al cliente. Para usar una instancia compartida en ese flujo, asociarla también al cliente; la herencia por tipo de sitio no se aplica a esa URL.
+
+`Notification` consume `MailService`; `Purchase` consume Telepagos. Los tenants mantienen el contexto operativo y el branding.
+
+## Despliegue
+
+Ejecutar `php artisan migrate` junto con este código. La migración `2026_09_04_000003` renombra `requires_client_configuration` a `requires_configuration` conservando sus valores. Los payloads del catálogo deben usar el nuevo nombre. Las migraciones previas trasladan el texto cifrado sin descifrarlo y no comparten instancias automáticamente.
+
+## Logging
+
+Telepagos registra eventos en el canal diario `telepagos`. El nivel y la retención se configuran con `TELEPAGOS_LOG_LEVEL` y `TELEPAGOS_LOG_DAYS`. Se eliminan tokens y credenciales de las estructuras registradas.

app/Domains/Integration/routes/api.php

@@ -1,10 +1,25 @@
 <?php
 
 use App\Domains\Integration\Controllers\ClientIntegrationController;
+use App\Domains\Integration\Controllers\TelepagosWebhookController;
+use App\Domains\Integration\Controllers\WebsiteTypeIntegrationController;
+use App\Domains\Integration\Models\Integration;
 use Illuminate\Support\Facades\Route;
 
-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::middleware(['auth:sanctum', 'can:manage,'.Integration::class])->group(function (): void {
+    Route::prefix('website-types/{websiteType:codigo}/integrations')->group(function (): void {
+        Route::get('/', [WebsiteTypeIntegrationController::class, 'index']);
+        Route::get('/{integration_code}', [WebsiteTypeIntegrationController::class, 'show']);
+        Route::put('/{integration_code}', [WebsiteTypeIntegrationController::class, 'store']);
+        Route::delete('/{integration_code}', [WebsiteTypeIntegrationController::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::delete('/{integration_code}', [ClientIntegrationController::class, 'destroy']);
+    });
 });
+
+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/Services/NotificationMailService.php

@@ -32,13 +32,14 @@ class NotificationMailService
             $tenant = Tenant::query()->with('websiteType')->where('codigo', $tenantCode)->firstOrFail();
             $user = User::query()->findOrFail($userId);
             $brand = $tenant->websiteType ?? $tenant;
+            $tenantUrl = 'https://'.$tenant->dominio.$tenant->base_path;
 
             $this->mailService
                 ->forTenant($tenantCode)
                 ->send(
                     $user->email,
                     "Bienvenido a {$brand->nombre}",
-                    view('mail.notifications.welcome', compact('brand', 'user'))->render(),
+                    view('mail.notifications.welcome', compact('brand', 'user', 'tenantUrl'))->render(),
                     $brand,
                 );
 
@@ -99,12 +100,25 @@ class NotificationMailService
                 : 'https://'.$recoveryDomain.$recoveryBasePath.'/recuperar-contrasena/codigo?'.http_build_query($recoveryQuery);
             $brand = $tenant->websiteType ?? $tenant;
 
+            [$subject, $template] = match ($attempt->reason) {
+                ResetPasswordAttempt::REASON_STAFF_CREATED => [
+                    'Tu cuenta de escáner está lista', 'scanner-created',
+                ],
+                ResetPasswordAttempt::REASON_ADMINISTRATOR_CREATED => [
+                    'Tu cuenta de administrador está lista', 'administrator-created',
+                ],
+                ResetPasswordAttempt::REASON_ACCOUNT_LOCKED => [
+                    'Desbloqueá tu cuenta', 'account-locked',
+                ],
+                default => ['Código para recuperar tu contraseña', 'password-reset'],
+            };
+
             $this->mailService
                 ->forTenant($tenantCode)
                 ->send(
                     $attempt->user->email,
-                    "Código para recuperar tu contraseña - {$brand->nombre}",
-                    view('mail.notifications.password-reset', [
+                    "{$subject} - {$brand->nombre}",
+                    view("mail.notifications.{$template}", [
                         'attempt' => $attempt,
                         'recoveryUrl' => $recoveryUrl,
                         'brand' => $brand,
@@ -138,8 +152,7 @@ class NotificationMailService
             }
 
             /** @var Collection<int, Ticket> $tickets */
-            $tickets = Ticket::query()
-                ->where('source_purchase_id', $purchase->getKey())
+            $tickets = $purchase->tickets()
                 ->where('tenant_code', $purchase->tenant_codigo)
                 ->with(TicketPresentationResolver::RELATIONS)
                 ->get();

app/Domains/Purchase/Controllers/PurchaseController.php

@@ -243,6 +243,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/Models/Purchase.php

@@ -14,6 +14,7 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
 use Illuminate\Database\Eloquent\Relations\HasOne;
 use Illuminate\Support\Facades\DB;
 
@@ -51,6 +52,14 @@ class Purchase extends Model
 
     public const STATUS_SUPERSEDED = 'superseded';
 
+    public const ADMIN_STATUS_INCOMPLETE = 'incomplete';
+
+    public const ADMIN_STATUS_AWAITING_PAYMENT = 'awaiting_payment';
+
+    public const ADMIN_STATUS_CONFIRMED = 'confirmed';
+
+    public const ADMIN_STATUS_CANCELLED = 'cancelled';
+
     /** @return list<string> */
     public static function statuses(): array
     {
@@ -66,6 +75,68 @@ class Purchase extends Model
         ];
     }
 
+    /**
+     * @return array<string, array{name: string, statuses: list<string>}>
+     */
+    public static function adminStatuses(): array
+    {
+        return [
+            self::ADMIN_STATUS_INCOMPLETE => [
+                'name' => 'Por completar datos',
+                'statuses' => [self::STATUS_CREATED],
+            ],
+            self::ADMIN_STATUS_AWAITING_PAYMENT => [
+                'name' => 'Esperando pago',
+                'statuses' => [self::STATUS_PENDING_PAYMENT, self::STATUS_IN_REVIEW],
+            ],
+            self::ADMIN_STATUS_CONFIRMED => [
+                'name' => 'Confirmado',
+                'statuses' => [self::STATUS_PAID],
+            ],
+            self::ADMIN_STATUS_CANCELLED => [
+                'name' => 'Anulado',
+                'statuses' => [
+                    self::STATUS_CANCELLED,
+                    self::STATUS_REJECTED,
+                    self::STATUS_EXPIRED,
+                    self::STATUS_SUPERSEDED,
+                ],
+            ],
+        ];
+    }
+
+    /** @return list<string> */
+    public static function adminStatusCodes(): array
+    {
+        return array_keys(self::adminStatuses());
+    }
+
+    /** @return list<string> */
+    public static function realStatusesForAdminStatus(string $adminStatus): array
+    {
+        return self::adminStatuses()[$adminStatus]['statuses'] ?? [];
+    }
+
+    public static function adminStatusFor(string $realStatus): ?string
+    {
+        foreach (self::adminStatuses() as $adminStatus => $definition) {
+            if (in_array($realStatus, $definition['statuses'], true)) {
+                return $adminStatus;
+            }
+        }
+
+        return null;
+    }
+
+    public static function adminStatusNameFor(string $realStatus): ?string
+    {
+        $adminStatus = self::adminStatusFor($realStatus);
+
+        return $adminStatus === null
+            ? null
+            : self::adminStatuses()[$adminStatus]['name'];
+    }
+
     protected $table = 'compras';
 
     /** @var array<int, string> */
@@ -115,12 +186,15 @@ class Purchase extends Model
         return $this->hasMany(PurchaseItem::class, 'compra_id');
     }
 
-    /**
-     * @return HasMany<Ticket, $this>
-     */
-    public function tickets(): HasMany
+    /** @return HasManyThrough<Ticket, PurchaseItem, $this> */
+    public function tickets(): HasManyThrough
     {
-        return $this->hasMany(Ticket::class, 'source_purchase_id');
+        return $this->hasManyThrough(
+            Ticket::class,
+            PurchaseItem::class,
+            'compra_id',
+            'source_purchase_item_id',
+        );
     }
 
     /** @return BelongsTo<StockReservation, $this> */
@@ -145,6 +219,12 @@ class Purchase extends Model
         return $this->hasMany(TelepagosPayment::class, 'compra_id');
     }
 
+    /** @return HasMany<TelepagosPaymentCandidate, $this> */
+    public function telepagosPaymentCandidates(): HasMany
+    {
+        return $this->hasMany(TelepagosPaymentCandidate::class, 'compra_id');
+    }
+
     public function getTotalAmount(): float
     {
         if ($this->total !== null) {

app/Domains/Purchase/Models/PurchaseItem.php

@@ -5,10 +5,12 @@ namespace App\Domains\Purchase\Models;
 use App\Domains\Attachable\Models\Attachment;
 use App\Domains\Catalog\Models\CatalogItem;
 use App\Domains\Catalog\Models\Variant;
+use App\Domains\Ticket\Models\Ticket;
 use Illuminate\Database\Eloquent\Attributes\Fillable;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 #[Fillable([
     'compra_id',
@@ -25,6 +27,7 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
     'discount_total',
     'tax_total',
     'total',
+    'refunded_amount',
 ])]
 class PurchaseItem extends Model
 {
@@ -45,6 +48,7 @@ class PurchaseItem extends Model
             'discount_total' => 'decimal:2',
             'tax_total' => 'decimal:2',
             'total' => 'decimal:2',
+            'refunded_amount' => 'decimal:2',
         ];
     }
 
@@ -56,6 +60,12 @@ class PurchaseItem extends Model
         return $this->belongsTo(Purchase::class, 'compra_id');
     }
 
+    /** @return HasMany<Ticket, $this> */
+    public function tickets(): HasMany
+    {
+        return $this->hasMany(Ticket::class, 'source_purchase_item_id');
+    }
+
     /** @return BelongsTo<Attachment, $this> */
     public function imageAttachment(): BelongsTo
     {