title: Modeles
description: Modelos usados en la aplicación mayeutica.school

Documentación de Modelos Eloquent - Mayeutica

Esta documentación describe los modelos Eloquent de Laravel que interactúan con las tablas de la base de datos de Mayeutica. Los modelos Eloquent proporcionan una interfaz fluida y orientada a objetos para trabajar con los datos.

Notas Importantes:

  • Esta documentación se basa en las convenciones de Laravel y la estructura de las tablas proporcionada. La implementación real en el código (atributos $fillable exactos, $casts, relaciones definidas) debe verificarse contra el código fuente.
  • Se asume que todos los modelos residen en el namespace App\Models.
  • Crucial: El modelo Sesion mapea a la tabla mytc_mayeutica_conceptos (no a una tabla de sesiones) y utiliza una conexión de base de datos secundaria (mysql2). Las claves foráneas id_sesion en otras tablas apuntan al id de la tabla mytc_mayeutica_conceptos. Se recomienda encarecidamente renombrar la tabla mytc_mayeutica_conceptos a mytc_mayeutica_sesiones para mayor claridad semántica.

Tabla de Contenidos

Modelo Blockchain

Representa un registro en la tabla mytc_mayeutica_blockchain, potencialmente relacionado con la generación de certificados o registros inmutables del progreso del curso.

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_blockchain
  • Conexión DB: mysql (default, a menos que se especifique lo contrario)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: No utiliza los timestamps created_at/updated_at de Eloquent (public $timestamps = false;). Usa marca_tiempo explícitamente.
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Blockchain extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_blockchain';
    public $timestamps = false; // No usa created_at/updated_at

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'hash_bloque',
        'hash_bloque_anterior',
        'marca_tiempo',
        'id_bloque_anterior',
        'id_nft',
        'id_curso',
        'id_usuario',
        'nombre_curso',
        'sesiones_cursadas',
    ];

    /**
     * Casting de atributos.
     */
    protected $casts = [
        'marca_tiempo' => 'datetime',
        'sesiones_cursadas' => 'integer',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el curso asociado a este registro blockchain.
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }

    /**
     * Obtiene el usuario asociado a este registro blockchain.
     */
    public function usuario() // Podría ser 'user' si sigue la convención
    {
        return $this->belongsTo(User::class, 'id_usuario');
    }

    /**
     * Obtiene el bloque anterior (auto-referencia).
     */
    public function bloqueAnterior()
    {
        return $this->belongsTo(Blockchain::class, 'id_bloque_anterior');
    }
}

Modelo Cupon

Gestiona los cupones de descuento (mytc_mayeutica_cupones).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_cupones
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Cupon extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_cupones';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'hash_cupon',
        'estado',
        'fecha_estado', // Considerar si necesita casting si se usa como fecha
    ];

    /**
     * Casting de atributos.
     * 'fecha_estado' es VARCHAR, podría necesitar un mutador/accesor si se maneja como fecha.
     */
    // protected $casts = [
    //     'fecha_estado' => 'date', // Solo si se asegura que el formato es compatible
    // ];

    // --- Relaciones Eloquent ---
    // No hay relaciones obvias basadas en las columnas.
}

Modelo Curso

Representa un curso ofrecido en la plataforma (mytc_mayeutica_cursos).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_cursos
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Curso extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_cursos';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'idn',
        'nombre',
        'name',
        'descripcion',
        'description',
        'Categoria',
        'Category',
        'indicacion',
        'precio',
    ];

    /**
     * Casting de atributos.
     */
    protected $casts = [
        'precio' => 'decimal:2',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene los temas asociados a este curso.
     */
    public function temas()
    {
        return $this->hasMany(Tema::class, 'id_curso');
    }

    /**
     * Obtiene las sesiones (mapeadas desde conceptos) asociadas a este curso a través de sus temas.
     */
    public function sesiones()
    {
        return $this->hasManyThrough(Sesion::class, Tema::class, 'id_curso', 'id_tema', 'id', 'id');
    }

     /**
     * Obtiene las indicaciones específicas para este curso.
     */
    public function indicaciones()
    {
        return $this->hasMany(Indicacion::class, 'id_curso');
    }

    /**
     * Obtiene las interacciones asociadas a este curso.
     */
    public function interacciones()
    {
        return $this->hasMany(Interaccion::class, 'id_curso');
    }

    /**
     * Obtiene las matrículas asociadas a este curso.
     */
    public function matriculas()
    {
        return $this->hasMany(Matricula::class, 'id_curso');
    }

     /**
     * Obtiene los pagos asociados a la compra de este curso.
     */
    public function pagos()
    {
        return $this->hasMany(Pago::class, 'id_curso');
    }

     /**
     * Obtiene los registros blockchain asociados a este curso.
     */
    public function registrosBlockchain()
    {
        return $this->hasMany(Blockchain::class, 'id_curso');
    }

    /**
     * Obtiene los usuarios matriculados en este curso.
     */
    public function usuariosMatriculados()
    {
        return $this->belongsToMany(User::class, 'mytc_mayeutica_matriculas', 'id_curso', 'id_user')
                    ->withPivot('id_sesion', 'estado', 'fecha_matricula') // Cargar datos adicionales de la tabla pivote
                    ->withTimestamps(); // Si quieres acceder a created_at/updated_at de la matrícula
    }
}

Modelo Indicacion

Representa indicaciones o pautas específicas para un usuario en un curso (mytc_mayeutica_indicaciones).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_indicaciones
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Indicacion extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_indicaciones';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_user',
        'id_curso',
        'indicacion',
        'pauta',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el usuario al que pertenece esta indicación.
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'id_user');
    }

    /**
     * Obtiene el curso al que pertenece esta indicación.
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }
}

Modelo Interaccion

Registra los mensajes intercambiados entre usuario y IA (mytc_mayeutica_interacciones).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_interacciones
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Interaccion extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_interacciones';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_user',
        'id_curso', // Puede ser nullable
        'id_sesion',
        'role',
        'content',
        'ia_provider',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el usuario que realizó la interacción.
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'id_user');
    }

    /**
     * Obtiene el curso asociado (si existe).
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }

    /**
     * Obtiene la sesión asociada.
     * Correcto: apunta a Sesion::class usando id_sesion, que a su vez usa la tabla conceptos.
     */
    public function sesion()
    {
        return $this->belongsTo(Sesion::class, 'id_sesion'); // Correcto
    }
}

Modelo Matricula

Representa la inscripción de un usuario en un curso (mytc_mayeutica_matriculas). Puede actuar como modelo independiente o tabla pivote.

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_matriculas
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
// use Illuminate\Database\Eloquent\Relations\Pivot; // Alternativa si se usa principalmente como pivote

class Matricula extends Model // o Pivot
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_matriculas';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_user',
        'id_curso',
        'id_sesion', // Puede ser nullable
        'estado',
        'fecha_matricula', // Puede ser nullable
    ];

    /**
     * Casting de atributos.
     */
    protected $casts = [
        'fecha_matricula' => 'date',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el usuario matriculado.
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'id_user');
    }

    /**
     * Obtiene el curso de la matrícula.
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }

    /**
     * Obtiene la sesión actual o última accedida (si aplica).
     * Correcto: apunta a Sesion::class usando id_sesion.
     */
    public function sesion()
    {
        return $this->belongsTo(Sesion::class, 'id_sesion'); // Correcto
    }
}

Modelo Pago

Almacena información sobre las transacciones de pago (mytc_mayeutica_pagos).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_pagos
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Pago extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_pagos';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_user',
        'id_transaccion',
        'fecha_transaccion', // VARCHAR, considerar manejo
        'nombre_pagador',
        'estado',
        'mail_pagador',
        'moneda',
        'valor',
        'id_curso', // Puede ser nullable
    ];

    /**
     * Casting de atributos.
     */
    protected $casts = [
        'valor' => 'decimal:2',
        // 'fecha_transaccion' => 'datetime', // Solo si el formato VARCHAR es compatible consistentemente
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el usuario asociado al pago (quien recibe el beneficio).
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'id_user');
    }

    /**
     * Obtiene el curso comprado con este pago (si aplica).
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }
}

Modelo Pregunta

Almacena preguntas de cuestionarios, respuestas de usuarios y evaluaciones (mytc_mayeutica_preguntas).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_preguntas
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Pregunta extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_preguntas';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_user',
        'id_sesion', // Puede ser nullable
        'consecutivo',
        'pregunta',
        'respuesta',
        'evaluacion',
        'calificacion',
        'calificador',
    ];

    /**
     * Casting de atributos.
     */
    protected $casts = [
        'consecutivo' => 'integer',
        'calificacion' => 'decimal:2',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el usuario que respondió la pregunta.
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'id_user');
    }

    /**
     * Obtiene la sesión a la que pertenece esta pregunta.
     * Correcto: apunta a Sesion::class usando id_sesion.
     */
    public function sesion()
    {
        return $this->belongsTo(Sesion::class, 'id_sesion'); // Correcto
    }
}

Modelo Sesion

Representa una sesión o lección específica dentro de un tema de un curso. Importante: Este modelo mapea a la tabla mytc_mayeutica_conceptos y utiliza la conexión mysql2.

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_conceptos (¡No mytc_mayeutica_sesiones!)
  • Conexión DB: mysql2 (No la default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at - basado en la tabla mytc_mayeutica_conceptos).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Sesion extends Model
{
    use HasFactory;

    // Especifica la conexión no predeterminada
    protected $connection = 'mysql2';

    // Especifica explícitamente la tabla (que semánticamente no coincide con el modelo)
    protected $table = 'mytc_mayeutica_conceptos';

    // Asume timestamps basados en las columnas de mytc_mayeutica_conceptos
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente, basados en las columnas
     * de 'mytc_mayeutica_conceptos'. ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_curso', // Heredado de conceptos
        'id_tema',  // Heredado de conceptos
        'nombre',   // Nombre de la sesión (antes concepto)
        'descripcion', // Descripción de la sesión (antes concepto)
    ];

    /**
     * Casting de atributos (si aplica).
     */
    // protected $casts = [];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el curso al que pertenece la sesión (vía columna id_curso).
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }

    /**
     * Obtiene el tema al que pertenece la sesión (vía columna id_tema).
     */
    public function tema()
    {
        return $this->belongsTo(Tema::class, 'id_tema');
    }

    /**
     * Obtiene las interacciones asociadas a esta sesión.
     */
    public function interacciones()
    {
        // Usa la clave foránea 'id_sesion' de la tabla interacciones
        // para relacionarla con la clave primaria 'id' de esta tabla (mytc_mayeutica_conceptos)
        return $this->hasMany(Interaccion::class, 'id_sesion');
    }

    /**
     * Obtiene las preguntas/respuestas asociadas a esta sesión.
     */
    public function preguntas()
    {
        return $this->hasMany(Pregunta::class, 'id_sesion');
    }

    /**
     * Obtiene las matrículas que apuntan a esta sesión como la actual.
     */
    public function matriculas() // Matriculas donde esta es la sesión actual
    {
        return $this->hasMany(Matricula::class, 'id_sesion');
    }
}

Modelo Tema

Representa un tema o módulo dentro de un curso (mytc_mayeutica_temas).

  • Namespace: App\Models
  • Tabla Asociada: mytc_mayeutica_temas
  • Conexión DB: mysql (default)
  • Clave Primaria: id (mediumint, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Tema extends Model
{
    use HasFactory;

    protected $table = 'mytc_mayeutica_temas';
    public $timestamps = true;

    /**
     * Atributos que pueden ser asignados masivamente.
     * ¡VERIFICAR EN EL CÓDIGO REAL!
     */
    protected $fillable = [
        'id_curso',
        'nombre',
        'descripcion',
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene el curso al que pertenece este tema.
     */
    public function curso()
    {
        return $this->belongsTo(Curso::class, 'id_curso');
    }

    /**
     * Obtiene las sesiones (mapeadas desde conceptos) asociadas a este tema.
     * Correcto: Relaciona con Sesion::class usando id_tema.
     */
    public function sesiones()
    {
        // Relaciona con el modelo Sesion usando la columna id_tema de mytc_mayeutica_conceptos
        return $this->hasMany(Sesion::class, 'id_tema'); // Correcto
    }
}

Modelo User

Representa un usuario registrado en la aplicación (users). Modelo estándar de autenticación de Laravel.

  • Namespace: App\Models
  • Tabla Asociada: users
  • Conexión DB: mysql (default)
  • Clave Primaria: id (bigint unsigned, auto-incrementing)
  • Timestamps: Habilitados (created_at, updated_at).
namespace App\Models;

// use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens; // Si se usa Sanctum para API tokens

class User extends Authenticatable // implements MustVerifyEmail (si se usa verificación de email)
{
    use HasApiTokens, HasFactory, Notifiable; // Ajustar Traits según uso

    /**
     * La tabla asociada con el modelo.
     * No es necesario si sigue la convención 'users'.
     */
    // protected $table = 'users';

    /**
     * Atributos que pueden ser asignados masivamente.
     * Ajustar según las necesidades de registro/actualización.
     */
    protected $fillable = [
        'name',
        'email',
        'password',
        'user_preferences', // Permitir guardar preferencias masivamente
    ];

    /**
     * Atributos que deben ser ocultados en las serializaciones.
     * Común para seguridad.
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * Atributos que deben ser casteados a tipos nativos.
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
        'password' => 'hashed', // Automáticamente hashea al asignar
        'user_preferences' => 'array', // O 'object' para castear JSON
    ];

    // --- Relaciones Eloquent ---

    /**
     * Obtiene las indicaciones asociadas a este usuario.
     */
    public function indicaciones()
    {
        return $this->hasMany(Indicacion::class, 'id_user');
    }

    /**
     * Obtiene las interacciones realizadas por este usuario.
     */
    public function interacciones()
    {
        return $this->hasMany(Interaccion::class, 'id_user');
    }

    /**
     * Obtiene las matrículas de este usuario.
     */
    public function matriculas()
    {
        return $this->hasMany(Matricula::class, 'id_user');
    }

    /**
     * Obtiene los pagos asociados a este usuario.
     */
    public function pagos()
    {
        return $this->hasMany(Pago::class, 'id_user');
    }

    /**
     * Obtiene las respuestas a preguntas dadas por este usuario.
     */
    public function preguntasRespondidas()
    {
        return $this->hasMany(Pregunta::class, 'id_user');
    }

    /**
     * Obtiene los registros blockchain asociados a este usuario.
     */
    public function registrosBlockchain()
    {
        // Asegúrate que la FK en mytc_mayeutica_blockchain sea 'id_usuario'
        return $this->hasMany(Blockchain::class, 'id_usuario');
    }

    /**
     * Obtiene los cursos en los que está matriculado el usuario.
     */
    public function cursosMatriculados()
    {
        return $this->belongsToMany(Curso::class, 'mytc_mayeutica_matriculas', 'id_user', 'id_curso')
                    ->withPivot('id_sesion', 'estado', 'fecha_matricula') // Cargar datos adicionales de la tabla pivote
                    ->withTimestamps();
    }
}

Este archivo único contiene toda la documentación de los modelos Eloquent basada en la información proporcionada. Recuerda la importancia de verificar los detalles como $fillable contra tu código fuente y considerar seriamente renombrar la tabla mytc_mayeutica_conceptos para mejorar la claridad.