CodeIgniter · el framework ligero

// routes/web.php (Laravel, manual anterior)
Route::get('/pedidos', [PedidoControlador::class, 'index']);

<?php
// app/Config/Routes.php (CodeIgniter 4)
$routes->get('/pedidos',             'PedidoControlador::index');
$routes->get('/pedidos/(:num)',      'PedidoControlador::show/$1');   // $1 = placeholder
$routes->post('/pedidos',            'PedidoControlador::create');

app/
  Config/        configuracion en CLASES PHP (Routes, Database, Filters, App)
  Controllers/   determinan el flujo (tu BaseController vive aqui)
  Database/      migraciones y seeds (gemelo de database/)
  Filters/       clases before/after (gemelo de Http/Middleware)
  Helpers/       colecciones de funciones sueltas
  Language/      cadenas de idioma
  Libraries/     clases que no encajan en otra parte
  Models/        entidades de negocio hacia la BD
  ThirdParty/    librerias ajenas manuales
  Views/         el HTML que se muestra

<VirtualHost *:80>
    DocumentRoot "/var/www/pedidos/public"
    ServerName   pedidos.local
    <Directory "/var/www/pedidos/public">
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

navegador
   |  GET /pedidos/5
   v
public/.htaccess      reescribe todo hacia public/index.php
   v
public/index.php      front controller: carga autoloader + bootstrap
   v
Config/Routes.php     busca la ruta: pedidos/(:num) -> show/$1
   v
PedidoControlador::show($id)   TU codigo consulta al modelo
   v
vista renderizada  ->  Response HTTP  ->  navegador

<?php
// app/Controllers/HolaControlador.php (recortado)
namespace App\Controllers;

class HolaControlador extends BaseController
{
    public function index(): string
    {
        return 'Hola desde CI4 — cuarta vuelta a Pedidos.';
    }
}

<?php
// app/Config/Routes.php — añade:
$routes->get('/hola', 'HolaControlador::index');

<?php
// fragmento de app/Config/App.php
namespace Config;

use CodeIgniter\Config\BaseConfig;

class App extends BaseConfig
{
    public string $baseURL   = 'http://localhost:8080/';
    public string $indexPage = 'index.php';
    public string $appTimezone = 'UTC';
    public string $charset   = 'UTF-8';
}

$app    = config('App');            // instancia compartida
$pagina = $app->indexPage;           // 'index.php'

$pager = new \Config\Pager();       // o instancia manual con new

<?php
helper('form');                    // carga form_helper.php
helper(['text', 'date']);          // varios a la vez

// desde un namespace concreto (modulos):
helper('Example\Blog\blog');

<?php
// app/Helpers/pedidos_helper.php   SIN namespace!
if (! function_exists('moneda')) {
    /**
     * Formato S/ para montos DECIMAL de la BD.
     */
    function moneda(float|string $monto): string
    {
        return 'S/ ' . number_format((float) $monto, 2);
    }
}

// Opcion A (desde 4.3): app/Config/Autoload.php
public array $helpers = ['pedidos'];

// Opcion B: propiedad del controlador (cap 8)
protected $helpers = ['pedidos', 'form'];

<?php
// app/Config/Routes.php
$routes->get('/pedidos',              'PedidoControlador::index');
$routes->get('/pedidos/(:num)',       'PedidoControlador::show/$1');
$routes->post('/pedidos',             'PedidoControlador::create');
$routes->put('/pedidos/(:num)',       'PedidoControlador::update/$1');
$routes->delete('/pedidos/(:num)',    'PedidoControlador::delete/$1');

// varios verbos en una linea:
$routes->match(['GET', 'POST'], '/contacto', 'Contacto::form');

$routes->addPlaceholder('uuid', '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}');
$routes->get('facturas/(:uuid)', 'FacturaControlador::show/$1');

// definicion:
$routes->get('pedidos/(:num)/detalle', 'PedidoControlador::detalle/$1',
             ['as' => 'pedido.detalle']);

// en cualquier vista o controlador:
<a href="<?= url_to('pedido.detalle', 15) ?>">Ver detalle</a>
// -> /pedidos/15/detalle   SIEMPRE actual

$routes->group('admin', ['filter' => 'session'], static function ($routes) {
    $routes->get('panel',     'Admin\Panel::index');       // admin/panel
    $routes->get('pedidos',   'Admin\Pedidos::index');     // admin/pedidos
});

// utilidades rapidas sin controlador:
$routes->view('/aviso', 'pages/mantenimiento');         // vista pura (GET)
$routes->addRedirect('/antiguo', '/nuevo');             // redireccion 302
$routes->environment('development', static function ($routes) {
    $routes->get('/sandbox', 'Herramientas::sandbox');  // SOLO en dev
});

<?php
// app/Controllers/BaseController.php (recortado)
abstract class BaseController extends Controller
{
    protected $request;
    protected $response;
    protected $logger;

    public function initController(
        RequestInterface  $request,
        ResponseInterface $response,
        LoggerInterface   $logger
    ) {
        $this->request  = $request;
        $this->response = $response;
        $this->logger   = $logger;
    }
}

<?php
// app/Controllers/PedidoControlador.php
namespace App\Controllers;

class PedidoControlador extends BaseController
{
    protected $helpers = ['pedidos', 'form'];

    public function index(): string
    {
        return moneda(258.20);   // disponible sin helper() manual
    }
}

<?php
namespace App\Controllers;

use App\Models\PedidoModelo;

class PedidoControlador extends BaseController
{
    protected $helpers = ['pedidos'];
    private PedidoModelo $pedidos;

    public function initController($request, $response, $logger)
    {
        parent::initController($request, $response, $logger);
        $this->pedidos = new PedidoModelo();     // cap 17: modelos CI4
    }

    public function index(): string              // GET /pedidos
    {
        return view('pedidos/lista', ['pedidos' => $this->pedidos->findAll()]);
    }

    public function show(int $id): string        // GET /pedidos/(:num)
    {
        return view('pedidos/detalle', ['pedido' => $this->pedidos->find($id)]);
    }
}

<?php
// app/Controllers/PedidoControlador.php
public function index(): string
{
    return view('pedidos/lista', [
        'pedidos' => $this->pedidos->findAll(),
        'titulo'  => 'Pedidos registrados',
    ]);
}

<!-- app/Views/pedidos/lista.php -->
<h1><?= esc($titulo) ?></h1>

<?php if (empty($pedidos)): ?>
    <p>Sin pedidos todavía.</p>
<?php else: ?>
    <table>
    <?php foreach ($pedidos as $p): ?>
        <tr>
            <td>#<?= (int) $p['id'] ?></td>
            <td><?= esc($p['cliente']) ?></td>
            <td><?= moneda($p['total']) ?></td>
        </tr>
    <?php endforeach ?>
    </table>
<?php endif ?>

<!-- app/Views/layout_pedidos.php -->
<!DOCTYPE html>
<html lang="es">
<head>
    <title><?= $this->renderSection('titulo') ?? 'Pedidos' ?></title>
</head>
<body>
    <nav>...menú común...</nav>
    <main>
        <?= $this->renderSection('contenido') ?>
    </main>
</body>
</html>

<!-- app/Views/pedidos/lista.php (ahora extiende) -->
<?= $this->extend('layout_pedidos') ?>

<?= $this->section('titulo') ?>Pedidos<?= $this->endSection() ?>

<?= $this->section('contenido') ?>
    ...la tabla de arriba...
<?= $this->endSection() ?>

// vista cacheada 60 segundos (gemelo de view caching):
return view('panel/metricas', $datos, ['cache' => 60,
                                       'cache_name' => 'panel-metricas']);

<!-- app/Views/parciales/tabla_pedidos.php -->
<table>
<?php foreach ($pedidos as $p): ?>
    <tr><td>#<?= (int) $p['id'] ?></td><td><?= esc($p['cliente']) ?></td></tr>
<?php endforeach ?>
</table>

<!-- dentro de cualquier vista o layout -->
<?= $this->include('parciales/tabla_pedidos', ['pedidos' => $pedidos]) ?>

<!-- tambien funciona concatenando view(): -->
<?= view('parciales/tabla_pedidos', ['pedidos' => $pedidos]) ?>

<?php
// app/Cells/Blog.php  (namespace App\Cells asumido)
namespace App\Cells;

class Blog
{
    public static function recientes(int $limit = 5): string
    {
        // consulta ligera + HTML construido
        return '<ul>...' . $limit . ' posts...</ul>';
    }
}

<?= view_cell('App\Cells\Blog::recientes', 'limit=5', 300, 'cell-blog') ?>

<?php
// app/Cells/AlertaEstadoCell.php (recortado)
namespace App\Views\Cells;

use CodeIgniter\View\Cells\Cell;

class AlertaEstadoCell extends Cell
{
    public string $estado = 'REGISTRADO';

    // logica inicial: recibe los parametros por NOMBRE
    public function mount(string $estado = 'REGISTRADO'): void
    {
        $this->estado = $estado;
    }

    // propiedad computada disponible como $color en la vista
    public function getColorProperty(): string
    {
        return match ($this->estado) {
            'PAGADO'     => 'success',
            'ANULADO'    => 'danger',
            default      => 'warning',
        };
    }
}

<!-- app/Views/cells/alerta_estado.php -->
<span class="badge text-bg-<?= $color ?>"><?= esc($estado) ?></span>

<!-- uso desde cualquier vista: -->
<?= view_cell('App\Views\Cells\AlertaEstadoCell', ['estado' => 'PAGADO']) ?>

<?php
// app/Filters/FiltroAdmin.php — esqueleto canonico
namespace App\Filters;

use CodeIgniter\Filters\FilterInterface;
use CodeIgniter\HTTP\RequestInterface;
use CodeIgniter\HTTP\ResponseInterface;

class FiltroAdmin implements FilterInterface
{
    public function before(RequestInterface $request, $arguments = null)
    {
        // devolver Response = CORTA la ejecucion aqui mismo
        if (! session('es_admin')) {
            return redirect()->to('/login')
                ->with('error', 'Zona restringida.');
        }
        // arguments = ['super', 'auditor'] si registraste 'filtro-admin:super,auditor'
    }

    public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
    {
        // SOLO puede modificar $response; jamas detiene nada
    }
}

<?php
// app/Config/Filters.php (recortado)
class Filters extends BaseFilters
{
    public array $aliases = [
        'csrf'         => CSRF::class,
        'session'      => Session::class,       // ejemplo: el nuestro, cap 31
        'filtro-admin' => FiltroAdmin::class,
    ];

    public array $required = [
        'before' => ['forcehttps', 'pagecache'],
        'after'  => ['pagecache', 'performance', 'toolbar'],
    ];

    public array $globals = [
        'before' => ['csrf'],                    // TODO post/put/delete
        'after'  => [],
    ];

    public array $methods = [
        'POST' => ['invalidchars'],              // solo peticiones POST
    ];

    public array $filters = [                     // por patron URI
        'session' => ['before' => ['panel/*', 'admin/*']],
    ];
}

$routes->get('admin/panel', 'Admin\Panel::index',
              ['filter' => 'filtro-admin']);

// con argumentos (llegan como arreglo en $arguments):
$routes->post('pedidos/anular/(:num)', 'PedidoControlador::anular/$1',
              ['filter' => 'filtro-admin:super,auditor']);

<!-- app/Views/pedidos/nuevo.php -->
<?= $this->extend('layout_pedidos') ?>
<?= $this->section('contenido') ?>

<form action="<?= site_url('pedidos') ?>" method="post">
    <?= csrf_field() ?>   <!-- campo oculto con el token -->

    <label>Cliente</label>
    <input type="text" name="cliente"
           value="<?= old('cliente') ?>">
    <span><?= validation_show_error('cliente') ?></span>

    <label>Total</label>
    <input type="text" name="total" value="<?= old('total') ?>">
    <span><?= validation_show_error('total') ?></span>

    <button>Registrar pedido</button>
</form>

<?= $this->endSection() ?>

<?php
public function guardar(): RedirectResponse   // POST /pedidos
{
    $reglas = [
        'cliente' => 'required|min_length[3]|max_length[120]',
        'total'   => 'required|decimal|greater[0]',
    ];

    if (! $this->validateData($this->request->getPost(), $reglas)) {
        return redirect()->back()->withInput()
            ->with('errors', $this->validator->getErrors());
    }

    $id = $this->pedidos->insert($this->request->getPost(), true);
    return redirect()->to("/pedidos/$id")
        ->with('success', "Pedido #$id registrado.");
}

$reglas = [
    'cliente' => [
        'rules'  => 'required|min_length[3]',
        'errors' => ['min_length' => 'El cliente necesita al menos 3 letras.'],
    ],
];

// app/Config/Validation.php
class Validation extends BaseValidation
{
    public array $pedido = [
        'cliente' => 'required|min_length[3]',
        'total'   => 'required|decimal|greater[0]',
    ];
}

// uso:
$validation = service('validation');
if (! $validation->run($this->request->getPost(), 'pedido')) {
    $errores = $validation->getErrors();
}

<?php
$session = session();                    // instancia compartida

$session->set('usuario_id', 7);
$session->set(['es_admin' => true]);     // arreglo a granel
$id      = $session->get('usuario_id');  // null si no existe
$admin   = session('es_admin');          // atajo lector (cap 11 lo usó)
$session->push('carrito', [$productoId]);// agrega a un valor-arreglo
$session->remove('usuario_id');
$session->destroy();                     // logout del cap 31

// controlador:
return redirect()->to("/pedidos/$id")->with('success', "Pedido #$id listo.");

// app/Views/layout_pedidos.php:
<?php if ($msg = session()->getFlashdata('success')): ?>
    <div class="alert alert-success"><?= esc($msg) ?></div>
<?php endif ?>

# .env  (prefijo database.default + propiedad EXACTA)
database.default.hostname = localhost
database.default.database = pedidos
database.default.username = pedidos_app
database.default.password = ClaveSegura2026!
database.default.DBDriver = MySQLi
database.default.port     = 3306

<?php
// app/Config/Database.php (recortado)
public array $default = [
    'hostname' => 'localhost',
    'username' => '',
    'password' => '',
    'database' => '',
    'DBDriver' => 'MySQLi',
    'DBPrefix' => '',            // prefijo comun de tablas
    'charset'  => 'utf8mb4',     // coincide con nuestra BD
    'DBCollat' => 'utf8mb4_general_ci',
    'strictOn' => false,
    'port'     => 3306,
];

<?php
$db    = \Config\Database::connect();       // conexion del grupo default
$forge = \Config\Database::forge();         // gemela para DDL (cap 15)

// prueba de fuego en una ruta temporal /db-check:
$version = $db->query('SELECT VERSION() AS v')->getRow()->v;
return "MariaDB {$version} — conexión OK";

<?php
namespace App\Database\Migrations;

use CodeIgniter\Database\Migration;

class CreateClientes extends Migration
{
    public function up(): void    { /* crear */ }

    public function down(): void  { /* deshacer */ }
}

<?php
public function up(): void
{
    $this->forge->addField([
        'id'         => ['type' => 'INT', 'constraint' => 11,
                         'unsigned' => true, 'auto_increment' => true],
        'nombre'     => ['type' => 'VARCHAR', 'constraint' => 120],
        'email'      => ['type' => 'VARCHAR', 'constraint' => 150,
                         'unique' => true],
        'created_at' => ['type' => 'DATETIME', 'null' => true],
        'updated_at' => ['type' => 'DATETIME', 'null' => true],
    ]);
    $this->forge->addKey('id', true);
    $this->forge->createTable('clientes', true);
}

public function down(): void
{
    $this->forge->dropTable('clientes', true);
}

$this->forge->addField([
    'id'       => ['type' => 'INT', 'constraint' => 11,
                   'unsigned' => true, 'auto_increment' => true],
    'nombre'   => ['type' => 'VARCHAR', 'constraint' => 150],
    'precio'   => ['type' => 'DECIMAL', 'constraint' => '10,2'],
    'stock'    => ['type' => 'INT', 'constraint' => 11, 'unsigned' => true,
                   'default' => 0],
    'activo'   => ['type' => 'TINYINT', 'constraint' => 1, 'default' => 1],
    ...created_at / updated_at...
]);
$this->forge->addKey('id', true);
$this->forge->createTable('productos', true);

<?php
// ...CreatePedidos.php  (up)
$this->forge->addField([
    'id'           => ['type' => 'INT', 'constraint' => 11,
                       'unsigned' => true, 'auto_increment' => true],
    'cliente_id'   => ['type' => 'INT', 'constraint' => 11, 'unsigned' => true],
    'estado'       => ['type' => 'ENUM',
                       'constraint' => ['REGISTRADO', 'PAGADO', 'ANULADO'],
                       'default' => 'REGISTRADO'],
    'total'        => ['type' => 'DECIMAL', 'constraint' => '10,2',
                       'default' => 0.00],
    'fecha_pedido' => ['type' => 'DATETIME'],
    ...created_at / updated_at...
]);
$this->forge->addKey('id', true);
$this->forge->addKey('cliente_id');                 // indice para el JOIN

// firma: addForeignKey($campo, $tablaRef, $campoRef, $onUpdate, $onDelete, $nombre)
$this->forge->addForeignKey('cliente_id', 'clientes', 'id');
$this->forge->createTable('pedidos', true);

$this->forge->addField([
    'id'             => [...id canonico...],
    'pedido_id'      => ['type' => 'INT', 'constraint' => 11, 'unsigned' => true],
    'producto_id'    => ['type' => 'INT', 'constraint' => 11, 'unsigned' => true],
    'cantidad'       => ['type' => 'INT', 'constraint' => 11, 'unsigned' => true],
    'precio_unitario'=> ['type' => 'DECIMAL', 'constraint' => '10,2'], // CONGELADO
]);
$this->forge->addKey('id', true);
$this->forge->addKey('pedido_id');
$this->forge->addForeignKey('pedido_id',   'pedidos',   'id');
$this->forge->addForeignKey('producto_id', 'productos', 'id');
$this->forge->createTable('pedido_detalles', true);

<?php
public function up(): void
{
    $this->forge->addColumn('productos', [
        'foto' => ['type' => 'VARCHAR', 'constraint' => 255,
                   'null' => true, 'after' => 'nombre'],
    ]);
}

public function down(): void
{
    $this->forge->dropColumn('productos', 'foto');
}

<?php
namespace App\Models;

use CodeIgniter\Model;

class PedidoModelo extends Model
{
    protected $table         = 'pedidos';
    protected $primaryKey    = 'id';
    protected $returnType    = 'array';       // u objeto/clase entidad
    protected $allowedFields = ['cliente_id', 'estado', 'total',
                                'fecha_pedido'];
    protected $useTimestamps = true;          // rellena created_at/updated_at
}

<?php
$pedidos = new \App\Models\PedidoModelo();

// CREATE — retorna el ID nuevo por defecto:
$id = $pedidos->insert(['cliente_id' => 1, 'estado' => 'REGISTRADO',
                        'total' => 258.20, 'fecha_pedido' => date('Y-m-d H:i:s')]);

// READ:
$pedido   = $pedidos->find($id);            // fila o null
$pagados  = $pedidos->where('estado', 'PAGADO')->findAll();
$ultimos  = $pedidos->orderBy('fecha_pedido', 'DESC')->findAll(10);
$primero  = $pedidos->where('estado', 'ANULADO')->first();

// UPDATE y DELETE:
$pedidos->update($id, ['estado' => 'PAGADO']);
$pedidos->delete($id);

// save(): upsert segun si el arreglo lleva la primaryKey:
$pedidos->save(['id' => $id, 'estado' => 'PAGADO']);   // update
$pedidos->save(['cliente_id' => 2, ...]);              // insert

<?php
protected $beforeInsert = ['ponerFechaPedido'];

protected function ponerFechaPedido(array $data): array
{
    if (! isset($data['data']['fecha_pedido'])) {
        $data['data']['fecha_pedido'] = date('Y-m-d H:i:s');
    }
    return $data;
}

<?php
protected $validationRules = [
    'estado' => 'required|in_list[REGISTRADO,PAGADO,ANULADO]',
    'total'  => 'decimal|greater_equal[0]',
];

<?php
namespace App\Database\Seeds;

use CodeIgniter\Database\Seeder;

class ClientesSeeder extends Seeder
{
    public function run(): void
    {
        // dataset canonico — DETERMINISTA, como en Laravel:
        $this->db->table('clientes')->insertBatch([
            ['nombre' => 'Ana Quispe',    'email' => 'ana@example.com'],
            ['nombre' => 'Luis Ramos',    'email' => 'luis@example.com'],
            ['nombre' => 'Carmen Rojas',  'email' => 'carmen@example.com'],
            ['nombre' => 'Diego Salazar', 'email' => 'diego@example.com'],
        ]);
    }
}

<?php
// app/Database/Seeds/DatabaseSeeder.php — orquestador
class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call('ClientesSeeder');
        $this->call('ProductosSeeder');
        $this->call('PedidosSeeder');
    }
}

// una sola orden siembra TODO:
// php spark migrate && php spark db:seed DatabaseSeeder

<?php
public function run(): void
{
    $this->db->table('pedidos')->insertBatch([
        ['cliente_id' => 1, 'estado' => 'PAGADO',     'total' => 258.20,
         'fecha_pedido' => '2026-08-20 10:00:00'],
        ['cliente_id' => 2, 'estado' => 'PAGADO',     'total' =>  62.85,
         'fecha_pedido' => '2026-08-21 11:30:00'],
        ['cliente_id' => 3, 'estado' => 'ANULADO',    'total' => 120.00,
         'fecha_pedido' => '2026-08-22 15:45:00'],
        ['cliente_id' => 1, 'estado' => 'REGISTRADO', 'total' =>  89.90,
         'fecha_pedido' => '2026-08-23 09:10:00'],
    ]);

    $this->db->table('pedido_detalles')->insertBatch([
        ['pedido_id' => 1, 'producto_id' => 1, 'cantidad' => 1,
         'precio_unitario' => 258.20],   // congelado al vender
    ]);
}

<?php
use CodeIgniter\Test\Fabricator;

$fabrica = new Fabricator(\App\Models\ProductoModelo::class);
$fabrica->setOverrides(['activo' => 1]);
$productos = $fabrica->create(28);   // INSERTA y devuelve las filas

// solo generar SIN tocar BD (para tests):
$borrador = $fabrica->make(5);

<?php
// app/Models/PedidoModelo.php — metodo de relacion
public function conCliente(): array
{
    return $this->select('pedidos.*, clientes.nombre AS cliente_nombre')
                ->join('clientes', 'clientes.id = pedidos.cliente_id')
                ->orderBy('pedidos.fecha_pedido', 'DESC')
                ->findAll();
}

// uso en el controlador (cap 20):
$filas = $this->pedidos->conCliente();
// cada fila trae cliente_nombre listo para esc() en la vista

<?php
// app/Models/DetalleModelo.php
class DetalleModelo extends Model
{
    protected $table = 'pedido_detalles';
    protected $allowedFields = ['pedido_id', 'producto_id',
                                'cantidad', 'precio_unitario'];

    /** Detalles del pedido + nombre del producto vendido. */
    public function dePedido(int $pedidoId): array
    {
        return $this->select('pedido_detalles.*, productos.nombre AS producto')
                    ->join('productos', 'productos.id = pedido_detalles.producto_id')
                    ->where('pedido_detalles.pedido_id', $pedidoId)
                    ->findAll();
    }
}

<?php
/** Clientes con su numero de pedidos. */
public function clientesConPedidos(): array
{
    return $this->db->table('clientes')
        ->select('clientes.*, COUNT(pedidos.id) AS total_pedidos', false)
        ->join('pedidos', 'pedidos.cliente_id = clientes.id', 'left')
        ->groupBy('clientes.id')
        ->orderBy('total_pedidos', 'DESC')
        ->get()->getResultArray();
}

<?php
// app/Config/Routes.php — nombres canonicos para url_to():
$routes->get('/pedidos', 'PedidoControlador::index',
             ['as' => 'pedidos.index']);
$routes->get('pedidos/(:num)', 'PedidoControlador::show/$1',
             ['as' => 'pedidos.show']);

<?php
// app/Controllers/PedidoControlador.php (recortado)
namespace App\Controllers;

use App\Models\PedidoModelo;
use App\Models\DetalleModelo;
use CodeIgniter\Exceptions\PageNotFoundException;

class PedidoControlador extends BaseController
{
    protected $helpers = ['pedidos'];
    private PedidoModelo $pedidos;
    private DetalleModelo $detalles;

    public function initController($request, $response, $logger)
    {
        parent::initController($request, $response, $logger);
        $this->pedidos  = new PedidoModelo();
        $this->detalles = new DetalleModelo();
    }

    public function index(): string
    {
        return view('pedidos/lista', [
            'filas' => $this->pedidos->conCliente(),
        ]);
    }

    public function show(int $id): string
    {
        $pedido = $this->pedidos->find($id);
        if ($pedido === null) {
            throw PageNotFoundException::forPageNotFound(
                "Pedido #$id no existe.");
        }
        return view('pedidos/detalle', [
            'pedido'   => $pedido,
            'detalles' => $this->detalles->dePedido($id),
        ]);
    }
}

<!-- app/Views/pedidos/lista.php -->
<?= $this->extend('layout_pedidos') ?>
<?= $this->section('contenido') ?>

<table class="table">
  <thead><tr><th>#</th><th>Cliente</th><th>Estado</th><th>Total</th></tr></thead>
  <tbody>
  <?php foreach ($filas as $f): ?>
    <tr>
      <td><a href="<?= url_to('pedidos.show', $f['id']) ?>">
            #<?= (int) $f['id'] ?></a></td>
      <td><?= esc($f['cliente_nombre']) ?></td>
      <td><?= view_cell('App\Views\Cells\AlertaEstadoCell',
                        ['estado' => $f['estado']]) ?></td>
      <td><?= moneda($f['total']) ?></td>
    </tr>
  <?php endforeach ?>
  </tbody>
</table>

<?= $this->endSection() ?>

<!-- app/Views/pedidos/detalle.php (recortado) -->
<p>Cliente: <b><?= esc($pedido['cliente_id']) ?></b> —
   <?= view_cell('App\Views\Cells\AlertaEstadoCell',
                 ['estado' => $pedido['estado']]) ?></p>

<table class="table">
<?php foreach ($detalles as $d): ?>
  <tr>
    <td><?= esc($d['producto']) ?></td>
    <td>x<?= (int) $d['cantidad'] ?></td>
    <td>vendido: <?= moneda($d['precio_unitario']) ?></td>
  </tr>
<?php endforeach ?>
</table>
<p class="fs-4 fw-bold">Total: <?= moneda($pedido['total']) ?></p>

<!-- app/Views/pedidos/nuevo.php (recortado) -->
<form action="<?= site_url('pedidos') ?>" method="post">
    <?= csrf_field() ?>
    <select name="cliente_id">
      <?php foreach ($clientes as $c): ?>
        <option value="<?= (int) $c['id'] ?>"><?= esc($c['nombre']) ?></option>
      <?php endforeach ?>
    </select>

    <input type="number" name="items[0][producto_id]" min="1" required>
    <input type="number" name="items[0][cantidad]"   min="1" value="1">

    <button>Registrar</button>
</form>

<?php
public function guardar(): RedirectResponse   // POST /pedidos
{
    $post = $this->request->getPost();

    // validacion basica del encabezado:
    if (! $this->validateData($post, ['cliente_id' => 'required|is_natural_no_zero'])) {
        return redirect()->back()->withInput()
            ->with('errors', $this->validator->getErrors());
    }

    $items = array_filter((array) ($post['items'] ?? []));

    $db = $this->pedidos->db;            // LA conexion del modelo
    $db->transStart();
    try {
        $total = 0.00; $lineas = [];

        foreach ($items as $item) {
            $prod = $this->productos->find((int) $item['producto_id']);
            if ($prod === null || $prod['stock'] < (int) $item['cantidad']) {
                throw new \RuntimeException('Producto invalido o sin stock.');
            }
            $congelado = (float) $prod['precio'];       // PRECIO CONGELADO
            $total += $congelado * (int) $item['cantidad'];

            $lineas[] = ['pedido_id' => null, 'producto_id' => $prod['id'],
                         'cantidad' => (int) $item['cantidad'],
                         'precio_unitario' => $congelado];
            $this->productos->update($prod['id'],
                         ['stock' => $prod['stock'] - (int) $item['cantidad']]);
        }

        $pedidoId = $this->pedidos->insert(['cliente_id' => (int) $post['cliente_id'],
                                            'estado' => 'REGISTRADO',
                                            'total' => $total,
                                            'fecha_pedido' => date('Y-m-d H:i:s')]);

        foreach ($lineas as &$l) { $l['pedido_id'] = $pedidoId; }
        $this->detalles->insertBatch($lineas);
    } catch (\Throwable $e) {
        // dentro de transStart NO lanza excepciones: marca el fallo...
        $db->transComplete();
        return redirect()->back()->withInput()
            ->with('error', $e->getMessage());
    }
    $db->transComplete();                 // ...y aqui decide commit o rollback

    return redirect()->to("/pedidos/$pedidoId")
        ->with('success', "Pedido #$pedidoId registrado.");
}

<?php
$db->transStart();
...consultas...
$db->transComplete();

if ($db->transStatus() === false) {
    log_message('error', 'Alta de pedido fallida: rollback aplicado.');
}

<?php
use CodeIgniter\Database\Exceptions\DatabaseException;

try {
    $db->transException(true)->transStart();
    ...
    $db->transComplete();
} catch (DatabaseException $e) {
    // ya hizo rollback automaticamente
}

<?php
// app/Models/PedidoModelo.php — el modelo guarda las reglas del dominio
public const EDITABLES = ['REGISTRADO'];

public function esEditable(int $id): bool
{
    $pedido = $this->find($id);
    return $pedido !== null && in_array($pedido['estado'], self::EDITABLES, true);
}

<?php
public function editar(int $id): string
{
    if (! $this->pedidos->esEditable($id)) {
        throw PageNotFoundException::forPageNotFound('Pedido no editable.');
    }
    return view('pedidos/editar', [
        'pedido' => $this->pedidos->find($id),
    ]);
}

public function actualizar(int $id): RedirectResponse   // POST
{
    if (! $this->pedidos->esEditable($id)) {
        return redirect()->back()->with('error', 'Estado terminal: inmutable.');
    }

    // grupo 'pedido' definido en Config/Validation.php (cap 12)
    $datos = $this->request->getPost();
    $validacion = service('validation');
    if (! $validacion->run($datos, 'pedido')) {
        return redirect()->back()->withInput()
            ->with('errors', $validacion->getErrors());
    }

    $this->pedidos->update($id, [
        'cliente_id' => (int) $datos['cliente_id'],
        'total'      => (float) $datos['total'],
    ]);
    return redirect()->to(url_to('pedidos.show', $id))
        ->with('success', "Pedido #$id actualizado.");
}

<form action="<?= site_url("pedidos/{$pedido['id']}/eliminar") ?>"
      method="post"
      onsubmit="return confirm('¿Eliminar este pedido?');">
    <?= csrf_field() ?>
    <button class="btn btn-danger btn-sm">Eliminar</button>
</form>

<?php
// routes: $routes->post('pedidos/(:num)/eliminar', 'PedidoControlador::eliminar/$1');

public function eliminar(int $id): RedirectResponse
{
    $pedido = $this->pedidos->find($id);

    if ($pedido === null || $pedido['estado'] !== 'REGISTRADO') {
        return redirect()->back()
            ->with('error', 'Solo los pedidos REGISTRADO se eliminan.');
    }

    // detalles primero: FK RESTRICT exige orden correcto
    $this->detalles->where('pedido_id', $id)->delete();
    $this->pedidos->delete($id);

    return redirect()->to(url_to('pedidos.index'))
        ->with('success', "Pedido #$id eliminado.");
}

<?php
// app/Models/PedidoModelo.php
public function porEstado(string $estado)
{
    return $this->where('estado', $estado);
}

public function buscar(string $termino)
{
    return $this->select('pedidos.*, clientes.nombre AS cliente_nombre')
                ->join('clientes', 'clientes.id = pedidos.cliente_id')
                ->like('clientes.nombre', $termino);   // %termino% both sides
}

public function entreFechas(string $desde, string $hasta)
{
    return $this->where('fecha_pedido >=', $desde . ' 00:00:00')
                ->where('fecha_pedido <=', $hasta . ' 23:59:59');
}

$resultado = $this->pedidos->buscar('ana')
                          ->porEstado('PAGADO')
                          ->orderBy('fecha_pedido', 'DESC')
                          ->findAll(20);

<?php
use CodeIgniter\Database\BaseBuilder;

public function sobrePromedio(): array
{
    return $this->where('total >', static function (BaseBuilder $b) {
        $b->select('AVG(total)', false)->from('pedidos');
    })->findAll();
}

<?php
/** [ ['estado'=>'PAGADO','cuantos'=>'2','importe'=>'321.05'], ... ] */
public function resumenPorEstado(): array
{
    return $this->select('estado')
                ->selectCount('id', 'cuantos')
                ->selectSum('total', 'importe')
                ->groupBy('estado')
                ->get()->getResultArray();
}

<?php
// controlador:
public function index(): string
{
    return view('pedidos/lista', [
        'filas' => $this->pedidos->paginate(20),   // pagina actual automatica
        'pager' => $this->pedidos->pager,           // objeto para links()
    ]);
}

<!-- app/Views/pedidos/lista.php — al final de la tabla: -->
<?= $pager->links() ?>

<?php
public function index(): string
{
    $termino = $this->request->getGet('q') ?? '';

    $consulta = $termino !== ''
        ? $this->pedidos->buscar($termino)
        : $this->pedidos;

    return view('pedidos/lista', [
        'filas'  => $consulta->orderBy('fecha_pedido', 'DESC')->paginate(20),
        'pager'  => $this->pedidos->pager,
        'q'      => $termino,
    ]);
}

<?= $pager->only(['q'])->links() ?>
<!-- genera ?q=ana&page=2 — conserva SOLO lo listado -->

<?php
// app/Controllers/PanelControlador.php (recortado)
public function index(): string
{
    $resumen = $this->pedidos->resumenPorEstado();     // Q1: GROUP BY estado

    // indexar por estado para lectura directa:
    $porEstado = [];
    foreach ($resumen as $fila) {
        $porEstado[$fila['estado']] = $fila;
    }

    return view('panel/index', [
        'porEstado'   => $porEstado,                          // Q1 reutilizada
        'ingresos'    => $porEstado['PAGADO']['importe'] ?? 0,
        'stockBajo'   => $this->productos->where('activo', 1)
                                       ->where('stock <=', 5)
                                       ->countAllResults(),   // Q2
        'topClientes' => $this->clientes->clientesConPedidos(),// Q3
    ]);
}

<?php
// app/Cells/Metricas.php
namespace App\Cells;

class Metricas
{
    public static function rankingClientes(int $limit = 5): string
    {
        $clientes = model(\App\Models\ClienteModelo::class)
            ->clientesConPedidos();

        $html = '<ol class="list-group">';
        foreach ($clientes as $c) {
            $html .= '<li>' . esc($c['nombre']) . ' — '
                   . (int) $c['total_pedidos'] . ' pedidos</li>';
        }
        return $html . '</ol>';
    }
}

<!-- app/Views/panel/index.php (recortado) -->
<div class="row g-3">
  <?php foreach (['REGISTRADO','PAGADO','ANULADO'] as $estado): ?>
    <div class="col-md-4">
      <div class="p-3 border rounded-3">
        <?= view_cell('App\Views\Cells\AlertaEstadoCell',
                      ['estado' => $estado]) ?>
        <p class="display-6 mb-0">
          <?= (int) ($porEstado[$estado]['cuantos'] ?? 0) ?></p>
      </div>
    </div>
  <?php endforeach ?>
</div>

<!-- bloque cacheado: TTL 300 s + id propio -->
<h3>Top clientes</h3>
<?= view_cell('App\Cells\Metricas::rankingClientes', '', 300, 'top-clientes') ?>

<?php
// app/Config/Routes.php
$routes->group('api', ['namespace' => 'App\Controllers\Api'],
    static function ($routes) {
        $routes->resource('pedidos', [
            'controller'  => 'PedidoControlador',
            'placeholder' => '(:num)',      // ids numericos, no (:segment)
            'except'      => 'new,edit',    // una API no tiene formularios HTML
            'filter'      => 'api-token',   // cap 28
        ]);
    });

<?php
// app/Controllers/Api/PedidoControlador.php
namespace App\Controllers\Api;

use CodeIgniter\RESTful\ResourceController;

class PedidoControlador extends ResourceController
{
    protected $modelName = 'App\Models\PedidoModelo';
    protected $format    = 'json';

    public function index()
    {
        return $this->respond($this->model->findAll());   // $model ya instanciado
    }
}

{
    "status": 400,
    "code": null,
    "messages": {"cliente_id": "The cliente_id field is required."}
}

return $this->setResponseFormat('json')->respond($datos);

<?php
// app/Entities/PedidoEntidad.php
namespace App\Entities;

use CodeIgniter\Entity\Entity;

class PedidoEntidad extends Entity
{
    protected $casts = [
        'total' => 'float',        // DECIMAL llega como STRING desde MariaDB
    ];
}

<?php
// app/Models/PedidoModelo.php — dos lineas nuevas:
protected $returnType = \App\Entities\PedidoEntidad::class;
protected $useTimestamps = true;

<?php
namespace App\Transformers;

use CodeIgniter\API\BaseTransformer;

class PedidoTransformer extends BaseTransformer
{
    public function toArray(mixed $resource): array
    {
        return [
            'id'           => (int) $resource['id'],
            'cliente_id'   => (int) $resource['cliente_id'],
            'estado'       => $resource['estado'],
            'total'        => (float) $resource['total'],
            'fecha_pedido' => $resource['fecha_pedido'],
        ];
        // ni created_at ni updated_at: no son asunto del cliente
    }

    protected function getAllowedFields(): ?array
    {
        return ['id', 'estado', 'total'];   // whitelist del ?fields=
    }
}

<?php
$pedido     = $this->model->find($id);
return $this->respond((new \App\Transformers\PedidoTransformer())
                      ->transform($pedido));

<?php
protected function getAllowedIncludes(): ?array
{
    return ['detalles'];   // sin esto, ApiException al pedirlo
}

protected function includeDetalles(): array
{
    $filas = model(\App\Models\DetalleModelo::class)
        ->dePedido((int) $this->resource['id']);

    return array_map(fn ($d) => [
        'producto'        => $d['producto'],
        'cantidad'        => (int) $d['cantidad'],
        'precio_unitario' => (float) $d['precio_unitario'],
    ], $filas);
}

// GET /api/pedidos?page=2  →  $this->paginate($this->model, 20,
//                                        PedidoTransformer::class):
{
    "data": [ {"id": 21, ...}, ... ],
    "meta": {"page": 2, "perPage": 20, "total": 34, "totalPages": 2},
    "links": {"self": "...page=2", "first": "...", "next": null}
}

<?php
public function up(): void
{
    $this->forge->addField([
        'id'         => ['type' => 'INT', 'constraint' => 11,
                         'unsigned' => true, 'auto_increment' => true],
        // usuario_id llegara en el cap 32 cuando existan usuarios
        'nombre'     => ['type' => 'VARCHAR', 'constraint' => 80],
        'token_hash' => ['type' => 'VARCHAR', 'constraint' => 64,
                         'unique' => true],
        'ultimo_uso' => ['type' => 'DATETIME', 'null' => true],
        'expira_en'  => ['type' => 'DATETIME', 'null' => true],
        'created_at' => ['type' => 'DATETIME', 'null' => true],
    ]);
    $this->forge->addKey('id', true);
    $this->forge->createTable('api_tokens', true);
}

<?php
// app/Libraries/Tokens.php
namespace App\Libraries;

class Tokens
{
    /** Devuelve [token_plano, id]. El plano SOLO se muestra al crearlo. */
    public static function emitir(string $nombre, ?string $dias = null): array
    {
        $plano = bin2hex(random_bytes(32));              // 64 caracteres

        $id = model(\App\Models\ApiTokenModelo::class)->insert([
            'nombre'     => $nombre,
            'token_hash' => hash('sha256', $plano),
            'expira_en'  => $dias ? date('Y-m-d H:i:s',
                                       strtotime("+$dias days")) : null,
        ]);
        return [$plano, $id];
    }
}

<?php
// app/Filters/FiltroApiToken.php
namespace App\Filters;

use CodeIgniter\Filters\FilterInterface;
use CodeIgniter\HTTP\RequestInterface;
use CodeIgniter\HTTP\ResponseInterface;

class FiltroApiToken implements FilterInterface
{
    public function before(RequestInterface $request, $arguments = null)
    {
        $header = $request->getHeaderLine('Authorization');

        if (! preg_match('/^Bearer\s+(\S+)$/', $header, $m)) {
            return service('response')->setStatusCode(401)
                ->setJSON(['status' => 401,
                           'messages' => ['error' => 'Token requerido.']]);
        }

        $fila = model(\App\Models\ApiTokenModelo::class)
            ->where('token_hash', hash('sha256', $m[1]))->first();

        if ($fila === null
            || ($fila['expira_en'] !== null && $fila['expira_en'] < date('Y-m-d H:i:s'))) {
            return service('response')->setStatusCode(401)
                ->setJSON(['status' => 401,
                           'messages' => ['error' => 'Token invalido o expirado.']]);
        }

        model(\App\Models\ApiTokenModelo::class)
            ->update($fila['id'], ['ultimo_uso' => date('Y-m-d H:i:s')]);
    }

    public function after(RequestInterface $r, ResponseInterface $resp, $a = null) {}
}

// app/Config/Filters.php
public array $aliases = [
    'csrf'       => CSRF::class,
    'api-token'  => \App\Filters\FiltroApiToken::class,
];

<?php
// app/Controllers/Api/PedidoControlador.php (recortado)
use App\Transformers\PedidoTransformer;

public function index()
{
    $estado = $this->request->getGet('estado');
    $q      = $this->request->getGet('q');
    $pagina = max(1, (int) ($this->request->getGet('page') ?? 1));
    $porPagina = 20;

    $consulta = ($q !== null && $q !== '')
        ? $this->model->buscar($q)
        : $this->model;

    if ($estado !== null && $estado !== '') {
        $consulta = $consulta->porEstado($estado);
    }

    $total    = (clone $consulta)->countAllResults();
    $filas    = $consulta->orderBy('fecha_pedido', 'DESC')
                          ->findAll($porPagina, ($pagina - 1) * $porPagina);

    return $this->respond([
        'data' => (new PedidoTransformer())->transformMany($filas),
        'meta' => ['pagina' => $pagina, 'por_pagina' => $porPagina,
                   'total' => $total,
                   'paginas' => (int) ceil($total / $porPagina)],
    ]);
}

<?php
public function show($id = null)
{
    $pedido = $this->model->find($id);
    if ($pedido === null) {
        return $this->failNotFound("Pedido $id no existe.");
    }
    return $this->respond(
        (new PedidoTransformer())->transform($pedido));
}

public function create()
{
    $datos = $this->request->getJSON(true);   // JSON body → arreglo

    $validacion = service('validation');
    if (! $validacion->run($datos, 'pedido')) {
        return $this->failValidationErrors($validacion->getErrors());
    }

    $id = $this->model->insert([
        'cliente_id'   => (int) $datos['cliente_id'],
        'estado'       => 'REGISTRADO',
        'total'        => (float) $datos['total'],
        'fecha_pedido' => date('Y-m-d H:i:s'),
    ]);

    return $this->respondCreated(['id' => $id]);
}

<?php
private const TRANSICIONES = [
    'REGISTRADO' => ['PAGADO', 'ANULADO'],
    // PAGADO y ANULADO: terminales, sin salida
];

public function update($id = null)
{
    $pedido = $this->model->find($id);
    if ($pedido === null) {
        return $this->failNotFound("Pedido $id no existe.");
    }

    $nuevo = $this->request->getJSON(true)['estado'] ?? '';
    $permitidos = self::TRANSICIONES[$pedido->estado] ?? [];

    if (! in_array($nuevo, $permitidos, true)) {
        return $this->failForbidden(
            "Transicion {$pedido->estado} → $nuevo no permitida.");
    }

    $this->model->update($id, ['estado' => $nuevo]);
    return $this->respond(['id' => (int) $id, 'estado' => $nuevo]);
}

public function delete($id = null)
{
    $pedido = $this->model->find($id);

    if ($pedido === null) {
        return $this->failNotFound("Pedido $id no existe.");
    }
    if ($pedido->estado !== 'REGISTRADO') {
        return $this->failForbidden('Solo REGISTRADO se elimina.');
    }

    model(\App\Models\DetalleModelo::class)
        ->where('pedido_id', $id)->delete();
    $this->model->delete($id);

    return $this->respondDeleted(['id' => (int) $id]);
}

<!-- app/Views/api/demo.php (dentro del layout) -->
<table class="table" id="tabla-pedidos"><tbody></tbody></table>

<form id="form-pedido">
    <input type="number" name="cliente_id" placeholder="ID cliente" required>
    <input type="number" name="total" step="0.01" placeholder="Total" required>
    <button>Crear</button>
</form>

<script src="/js/api-demo.js"></script>

// public/js/api-demo.js
const API = '/api/pedidos';
// DEMO: token fijo para aprender. En produccion NUNCA hardcodeado ni
// en localStorage si hay riesgo XSS (leccion del cap seguridad de js_01):
const TOKEN = 'a3f8c92e...';   // tu token emitido en el cap 28

async function api(ruta, opciones = {}) {
    const resp = await fetch(API + ruta, {
        ...opciones,
        headers: {
            'Authorization': `Bearer ${TOKEN}`,
            'Content-Type': 'application/json',
            ...opciones.headers,
        },
    });
    const cuerpo = await resp.json();
    if (!resp.ok) {
        // shape canónico de fail(): {status, code, messages}
        throw new Error(cuerpo?.messages?.error
            ?? Object.values(cuerpo?.messages ?? {}).join(' ')
            ?? `HTTP ${resp.status}`);
    }
    return cuerpo;
}

async function listar() {
    const {data} = await api('');
    document.querySelector('#tabla-pedidos tbody').innerHTML =
        data.map(p => `
            <tr>
                <td>#${p.id}</td>
                <td>${p.estado}</td>
                <td>S/ ${p.total.toFixed(2)}</td>
                <td>${p.estado === 'REGISTRADO'
                    ? `<button data-id="${p.id}" class="pagar">Pagar</button>`
                    : ''}</td>
            </tr>`).join('');
}

document.querySelector('#form-pedido').addEventListener('submit', async e => {
    e.preventDefault();
    const fd = new FormData(e.target);
    try {
        await api('', {
            method: 'POST',
            body: JSON.stringify({
                cliente_id: Number(fd.get('cliente_id')),
                total: Number(fd.get('total')),
            }),
        });
        await listar();
    } catch (err) {
        alert(err.message);   // ej: validación 400 con mensajes por campo
    }
});

document.addEventListener('click', async e => {
    if (!e.target.matches('.pagar')) return;
    try {
        await api(`/${e.target.dataset.id}`, {
            method: 'PATCH',
            body: JSON.stringify({estado: 'PAGADO'}),
        });
        await listar();
    } catch (err) {
        alert(err.message);   // 403: "Transicion PAGADO → PAGADO no permitida."
    }
});

listar();

<?php
public function up(): void
{
    $this->forge->addField([
        'id'            => [...id canonico...],
        'nombre'        => ['type' => 'VARCHAR', 'constraint' => 120],
        'email'         => ['type' => 'VARCHAR', 'constraint' => 150,
                           'unique' => true],
        'password_hash' => ['type' => 'VARCHAR', 'constraint' => 255],
        'es_admin'      => ['type' => 'TINYINT', 'constraint' => 1,
                           'default' => 0],
        ...created_at / updated_at...
    ]);
    $this->forge->addKey('id', true);
    $this->forge->createTable('usuarios', true);
}

<?php
public function registrar(): RedirectResponse   // POST /registro
{
    $datos = $this->request->getPost();

    if (! $this->validateData($datos, [
        'nombre' => 'required|min_length[3]',
        'email'  => 'required|valid_email|is_unique[usuarios.email]',
        'clave'  => 'required|min_length[8]|max_length[72]',
    ])) {
        return redirect()->back()->withInput()
            ->with('errors', $this->validator->getErrors());
    }

    model(\App\Models\UsuarioModelo::class)->insert([
        'nombre'        => $datos['nombre'],
        'email'         => $datos['email'],
        'password_hash' => password_hash($datos['clave'], PASSWORD_DEFAULT),
    ]);

    return redirect()->to('/ingresar')->with('success', 'Ya puedes entrar.');
}

<?php
public function ingresar(): RedirectResponse   // POST /ingresar
{
    $email = $this->request->getPost('email');
    $clave = $this->request->getPost('clave');

    $usuario = model(\App\Models\UsuarioModelo::class)
        ->where('email', $email)->first();

    // mensaje UNICO: un atacante no debe saber si fallo el email o la clave
    if ($usuario === null || ! password_verify($clave, $usuario['password_hash'])) {
        return redirect()->back()->withInput()
            ->with('error', 'Credenciales invalidas.');
    }

    session()->set([
        'usuario_id' => $usuario['id'],
        'nombre'     => $usuario['nombre'],
        'es_admin'   => (bool) $usuario['es_admin'],
    ]);
    session()->regenerate();     // ID nuevo: session fixation abortada

    return redirect()->to('/panel');
}

public function salir(): RedirectResponse      // GET /salir
{
    session()->destroy();
    return redirect()->to('/')->with('success', 'Sesion cerrada.');
}

<!-- app/Views/layout_pedidos.php, en la barra -->
<?php if (session('nombre')): ?>
    <span><?= esc(session('nombre')) ?></span>
    <a href="<?= site_url('salir') ?>">Salir</a>
<?php else: ?>
    <a href="<?= site_url('ingresar') ?>">Entrar</a>
<?php endif ?>

<?php
// app/Filters/FiltroAdmin.php — ahora con sesion real (cap 11 era teaser)
public function before(RequestInterface $request, $arguments = null)
{
    if (! session('usuario_id')) {
        return redirect()->to('/ingresar')
            ->with('error', 'Inicia sesion primero.');
    }
    if (! session('es_admin')) {
        return redirect()->back()
            ->with('error', 'Zona solo para administradores.');
    }
}

// app/Config/Routes.php
$routes->group('admin', ['filter' => 'filtro-admin'],
    static function ($routes) {
        $routes->get('panel', 'Admin\Panel::index');
        $routes->get('usuarios', 'Admin\Usuarios::index');
    });

<?php
private function exigirAdmin(): void
{
    if (! session('es_admin')) {
        throw PageNotFoundException::forPageNotFound();  // 404, ni confiesa
    }
}

public function anular(int $id): RedirectResponse
{
    $this->exigirAdmin();
    // solo admin llega aqui...
}

<?php
public function up(): void
{
    $this->forge->addColumn('api_tokens', [
        'usuario_id' => ['type' => 'INT', 'constraint' => 11,
                         'unsigned' => true, 'null' => true,
                         'after' => 'nombre'],
    ]);
    $this->forge->addForeignKey('usuario_id', 'usuarios', 'id',
                                '', '', 'fk_tokens_usuario');
}
// nota: addForeignKey en ALTER puede requerir processIndexes segun driver;
// si tu MariaDB lo aplica directo, perfecto.

<?php
// Tokens::emitir ahora recibe dueno:
[$plano, $id] = \App\Libraries\Tokens::emitir('panel-spa', null, $usuarioId);

// FiltroApiToken guarda el dueno para los controladores:
\App\Libraries\ApiAuth::$usuarioId = $fila['usuario_id'];

// app/Libraries/ApiAuth.php — compartido por request:
class ApiAuth
{
    public static ?int $usuarioId = null;
    public static bool $esAdmin = false;
}

<!-- VULNERABLE: dato crudo al HTML -->
<p>Hola <?= $nombre ?></p>

<!-- BLINDADO: esc() neutraliza <script>, comillas, todo -->
<p>Hola <?= esc($nombre) ?></p>

// VULNERABLE: concatenacion directa — jamas:
$db->query("SELECT * FROM usuarios WHERE email = '$email'");

// BLINDADO A: bindings manuales con ?
$db->query('SELECT * FROM usuarios WHERE email = ?', [$email]);

// BLINDADO B: query builder SIEMPRE escapa valores:
model(UsuarioModelo::class)->where('email', $email)->first();

<?php
// app/Config/Filters.php — endurecimiento para produccion:
public array $globals = [
    'before' => ['csrf', 'secureheaders'],
    'after'  => ['secureheaders'],
];

// o global via required, mas CORS para APIs multi-dominio:
protected array $required = [
    'before' => ['forcehttps', 'pagecache'],
    'after'  => ['pagecache', 'performance', 'toolbar', 'secureheaders'],
];

<form action="<?= site_url("productos/{$p['id']}/foto") ?>"
      method="post" enctype="multipart/form-data">
    <?= csrf_field() ?>
    <input type="file" name="foto" accept="image/jpeg,image/png,image/webp">
    <button>Subir foto</button>
</form>

<?php
public function guardarFoto(int $id): RedirectResponse   // POST
{
    $reglas = [
        'foto' => [
            'rules' => 'uploaded[foto]|is_image[foto]'
                     . '|mime_in[foto,image/jpg,image/jpeg,image/png,image/webp]'
                     . '|max_size[foto,2048]|max_dims[foto,3000,3000]',
            'errors' => ['max_size' => 'La foto supera los 2 MB.'],
        ],
    ];

    // OJO: required NO funciona con archivos — uploaded[foto] hace ese papel
    if (! $this->validateData([], $reglas)) {
        return redirect()->back()
            ->with('errors', $this->validator->getErrors());
    }

    $foto = $this->request->getFile('foto');
    if (! $foto->isValid()) {
        return redirect()->back()->with('error', 'Subida invalida.');
    }

    $nombre = $foto->getRandomName();                    // nombre seguro
    $ruta   = ROOTPATH . 'public/uploads/productos';
    $foto->move($ruta, $nombre);                         // mueve del tmp

    model(\App\Models\ProductoModelo::class)
        ->update($id, ['foto' => 'uploads/productos/' . $nombre]);

    return redirect()->back()->with('success', 'Foto actualizada.');
}

<!-- pintar la foto del catalogo -->
<img src="<?= base_url(esc($p['foto'])) ?>" alt="<?= esc($p['nombre']) ?>">

<?php
namespace App\Jobs;

use CodeIgniter\Queue\BaseJob;

class GenerarReporteVentas extends BaseJob
{
    protected int $tries      = 3;    // reintentos ante fallo
    protected int $retryAfter = 60;   // segundos entre intentos

    public function process(): void
    {
        // los parametros llegan serializados en $this->data:
        $fecha = $this->data['fecha'] ?? date('Y-m-d');

        $filas = model(\App\Models\PedidoModelo::class)->
            builder()->select('estado, COUNT(id) AS cuantos', false)->
            groupBy('estado')->get()->getResultArray();

        $resumen = array_column($filas, 'cuantos', 'estado');

        if (! is_dir(WRITEPATH . 'reportes')) {
            mkdir(WRITEPATH . 'reportes', 0775, true);
        }
        file_put_contents(
            WRITEPATH . "reportes/ventas-$fecha.json",
            json_encode($resumen, JSON_PRETTY_PRINT)
        );
        // => {"PAGADO": 2, "ANULADO": 1, "REGISTRADO": 1}
    }
}

<?php
// app/Config/Queue.php  (php spark queue:publish)
public array $jobHandlers = [
    'generar-reporte' => \App\Jobs\GenerarReporteVentas::class,
];

<?php
// donde toque (controlador, evento, tarea):
$result = service('queue')->push('default', 'generar-reporte',
                                 ['fecha' => '2026-08-24']);

if (! $result) {           // QueuePushResult
    log_message('error', 'No se pudo encolar: ' . $result->getError());
}

<?php
// app/Controllers/Api/PedidoControlador.php — dentro de update():
$this->model->update($id, ['estado' => $nuevo]);

if ($nuevo === 'PAGADO') {
    \CodeIgniter\Events\Events::trigger('pedido.pagado', (int) $id);
}
return $this->respond(['id' => (int) $id, 'estado' => $nuevo]);

<?php
// app/Config/Events.php
namespace Config;

use CodeIgniter\Events\Events;

Events::on('pedido.pagado', static function (int $pedidoId): void {
    // 1) sincrono rapido: refrescar contadores cacheados
    cache()->delete('top-clientes');        // invalida el cell del cap 25
});

Events::on('pedido.pagado', static function (int $pedidoId): void {
    // 2) pesado: ENCOLAR el envio del recibo (cap 35 + cap 37)
    service('queue')->push('emails', 'enviar-recibo',
                           ['pedido_id' => $pedidoId]);
}, Events::PRIORITY_LOW);   // corre DESPUES del primero

<?php
// app/Config/Email.php (recortado)
public string $protocol = 'smtp';
public string $SMTPHost = 'localhost';
public string $SMTPPort = '1025';      // Mailpit
public string $SMTPCrypto = '';        // solo para 587 tls / 465 ssl
public string $mailType = 'html';
public string $fromEmail = 'pedidos@tienda.test';
public string $fromName  = 'Pedidos Tienda';

<?php
namespace App\Jobs;

use CodeIgniter\Queue\BaseJob;

class EnviarRecibo extends BaseJob
{
    protected int $tries = 3;

    public function process(): void
    {
        $pedidoId = (int) ($this->data['pedido_id'] ?? 0);

        $pedido = model(\App\Models\PedidoModelo::class)->find($pedidoId);
        if ($pedido === null) {
            return;    // nada que enviar
        }

        $email = service('email');
        $email->setTo($this->data['email'] ?? 'cliente@example.com')
              ->setSubject("Recibo pedido #$pedidoId")
              ->setMessage(view('emails/recibo', ['pedido' => $pedido]));

        if (! $email->send()) {                 // send() devuelve BOOL
            log_message('error', "Fallo envio recibo #$pedidoId");
            throw new \RuntimeException('SMTP rechazo el envio');
            // lanzar = el worker reintenta segun tries
        }
    }
}

<!-- app/Views/emails/recibo.php — tablas, no divs: los clientes de correo -->
<p>Hola, gracias por tu compra.</p>
<p>Tu pedido <b>#<?= (int) $pedido['id'] ?></b> quedo
   en estado <?= esc($pedido['estado']) ?>.</p>
<p>Total: <b><?= moneda($pedido['total']) ?></b></p>

<?php
// si send() devolvio false:
$email->send(false);                          // NO limpia los datos
printDebugger(['headers', 'subject']);       // conversacion SMTP completa

// y el evento core 'email' se dispara tras CADA envio exitoso:
Events::on('email', static function (array $props): void {
    log_message('info', "Correo a {$props['toEmail']} enviado.");
});

<?php
// app/Config/Tasks.php
namespace Config;

use CodeIgniter\Tasks\Config\Tasks as BaseTasks;
use CodeIgniter\Tasks\Scheduler;

class Tasks extends BaseTasks
{
    public function init(Scheduler $schedule): void
    {
        // 1) comando spark propio (lo creamos abajo):
        $schedule->command('pedidos:reporte --fecha=hoy')
                 ->daily('11:50 pm')
                 ->named('reporte-diario');

        // 2) closure rapida cada 5 minutos:
        $schedule->call(static function () {
            cache()->delete('top-clientes');
        })->everyFiveMinutes();

        // 3) JOB de cola: el scheduler despacha, el worker ejecuta:
        $schedule->queue('default', 'generar-reporte', ['fecha' => 'hoy'])
                 ->hourly()
                 ->singleInstance(30 * MINUTE);   // no duplicar si sigue vivo
    }
}

<?php
// app/Commands/PedidosReporte.php (recortado)
use CodeIgniter\CLI\BaseCommand;
use CodeIgniter\CLI\CLI;

class PedidosReporte extends BaseCommand
{
    protected $group       = 'Pedidos';
    protected $name        = 'pedidos:reporte';
    protected $description = 'Genera el reporte de ventas del dia.';

    public function run(array $params): void
    {
        service('queue')->push('default', 'generar-reporte',
                               ['fecha' => CLI::getOption('fecha') ?? 'hoy']);
        CLI::write('Reporte encolado.', 'green');
    }
}

<?php
// app/Config/Cache.php (recortado)
public string $handler = 'file';       // apcu|dummy|file|memcached|redis|predis|wincache
public string $backupHandler = 'file';
public string $prefix  = '';
public int    $ttl     = 60;           // default general, en SEGUNDOS

<?php
// app/Controllers/PanelControlador.php — reemplazo del calculo directo:
$topClientes = cache()->remember('top-clientes', 300,
    static fn () => model(\App\Models\ClienteModelo::class)->
                     clientesConPedidos());

// primera peticion: ejecuta el closure y GUARDA 300 s
// siguientes: devuelve lo guardado SIN tocar MariaDB

<?php
// Events.php — al marcar PAGADO:
Events::on('pedido.pagado', static function (int $id): void {
    cache()->delete('top-clientes');   // stale data fuera AL INSTANTE
});

# .env — grupo "tests" aparte (gemelo del sqlite :memory: de Laravel):
database.tests.hostname = localhost
database.tests.database = pedidos_test
database.tests.username = pedidos_app
database.tests.DBDriver = MySQLi

<?php
namespace App\Tests;

use CodeIgniter\Test\CIUnitTestCase;
use CodeIgniter\Test\DatabaseTestTrait;
use CodeIgniter\Test\FeatureTestTrait;

final class PedidosApiTest extends CIUnitTestCase
{
    use DatabaseTestTrait, FeatureTestTrait;

    protected $refresh = true;   // regress + migrate ANTES de cada test

    public function testListaPedidosConTokenValido(): void
    {
        $this->seed('App\Database\Seeds\DatabaseSeeder');

        [$token] = \App\Libraries\Tokens::emitir('test');

        $resultado = $this->withHeaders([
                'Authorization' => "Bearer {$token}",
            ])->get('/api/pedidos');

        $resultado->assertStatus(200);
        $resultado->assertJSONFragment(['estado' => 'PAGADO']);
    }

    public function testTransicionProhibidaDevuelve403(): void
    {
        $this->seed('App\Database\Seeds\DatabaseSeeder');
        [$token] = \App\Libraries\Tokens::emitir('test');

        // pedido #1 ya esta PAGADO segun el seeder canonico:
        $resultado = $this->withHeaders([
                'Authorization' => "Bearer {$token}",
            ])->withBody(json_encode(['estado' => 'PAGADO']))
             ->withBodyFormat('json')
             ->patch('/api/pedidos/1');

        $resultado->assertStatus(403);
    }

    public function testCrearPersisteEnBase(): void
    {
        $this->seed('App\Database\Seeds\DatabaseSeeder');
        [$token] = \App\Libraries\Tokens::emitir('test');

        $this->withHeaders(['Authorization' => "Bearer {$token}"])
             ->withBody(json_encode(['cliente_id' => 1, 'total' => 99.90]))
             ->withBodyFormat('json')
             ->post('/api/pedidos')
             ->assertStatus(201);

        $this->seeInDatabase('pedidos', ['total' => '99.90',
                                         'estado' => 'REGISTRADO']);
    }
}

<?php
log_message('error', 'Fallo pago pedido #{id}', ['id' => $id]);
// writable/logs/log-2026-08-24.log:
// ERROR - 2026-08-24 14:03:11 -- Fallo pago pedido #4

<?php
// app/Config/Events.php
use CodeIgniter\Database\Query;

Events::on('DBQuery', static function (Query $query): void {
    $duracion = $query->getDuration();     // segundos (float)

    if ($duracion > 0.5) {
        log_message('warning', 'Query lenta ({t}s): {sql}', [
            't'   => round($duracion, 2),
            'sql' => $query->getQuery(),
        ]);
    }
});

<?php
// app/Filters/FiltroMantenimiento.php (recortado)
public function before(RequestInterface $request, $arguments = null)
{
    if (! file_exists(WRITEPATH . 'mantenimiento')) {
        return;    // puerta abierta
    }

    // bypass: quien tenga la cookie pasa (tu verificacion post-deploy):
    if ($request->getCookie('paso-servicio') === env('mantenimiento.llave')) {
        return;
    }

    return service('response')->setStatusCode(503)
        ->setBody(view('errors/mantenimiento'));
}

<?php
// activar / desactivar:
touch(WRITEPATH . 'mantenimiento');
unlink(WRITEPATH . 'mantenimiento');

// tu acceso: una visita a /paso-servicio?llave=... emite la cookie:
$routes->get('paso-servicio', static function () {
    $llave = $this->request->getGet('llave');   // o service request
    if ($llave === env('mantenimiento.llave')) {
        return service('response')->setCookie(
            'paso-servicio', $llave, HOUR * 4)->redirect(base_url());
    }
});