lunes, 5 de mayo de 2025

Herramientas fundamentales para aprender para CI/CD

1. Git (Primero)

Qué es: Sistema de control de versiones.
Para qué sirve: Te permite llevar el control de los cambios en tu código fuente localmente y en equipo.
Aprendizaje clave: git init, git add, git commit, git push, git pull, branch, merge, etc.
Es la base. Todo lo demás depende de saber Git.

2. GitLab (Segundo)

Qué es: Plataforma de alojamiento de repositorios Git (como GitHub), con herramientas de integración continua y gestión de proyectos.
Para qué sirve: Subes tus repositorios, colaboras con otros y automatizas procesos.
Aprendizaje clave: cómo subir proyectos, usar issues, pipelines, merge requests, etc.

Puedes aprender GitHub o GitLab indistintamente, ya que cumplen funciones similares. Si tu empresa usa GitLab, aprende GitLab. Si usas GitHub, sigue con GitHub.

3. GitHub Actions o GitLab CI/CD (Tercero)

Qué es: Herramientas de integración y entrega continua (CI/CD).
Para qué sirve: Automatizar tareas como pruebas, despliegue de código, compilación, etc.
Aprendizaje clave:
- YAML básico
- Definir workflows
- Automatizar builds, tests, deploys

Git → base fundamental.
GitHub o GitLab → elegir una plataforma para alojar repositorios.
GitHub Actions o GitLab CI/CD → automatización avanzada con pipelines.

viernes, 25 de abril de 2025

Cómo crear un plugin básico de actividad en Moodle (paso a paso)

Crear tu propio plugin en Moodle puede sonar complicado al principio, pero con este tutorial te mostraré cómo desarrollar un plugin básico de tipo “actividad” para que puedas entender la estructura y empezar a construir tus propias funcionalidades.

¿Qué vamos a crear?

Un plugin de actividad llamado Mi Módulo, que aparecerá en el listado de actividades cuando edites un curso y te permitirá crear nuevas instancias con un solo campo: nombre.

Estructura del plugin

Primero, crea una carpeta en:


moodle/mod/mimodulo

Dentro de esa carpeta, necesitas tener al menos estos archivos:


mimodulo/
├── db/
│   └── install.xml
         acces.php
├── lang/
│   └── en/
│       └── mimodulo.php
├── lib.php
├── mod_form.php
├── version.php
├── view.php

1. version.php

Archivo obligatorio que define la versión del plugin.


<?php
defined('MOODLE_INTERNAL') || die();

$plugin->component = 'mod_mimodulo';
$plugin->version = 2025042500;
$plugin->requires = 2022041900;
$plugin->maturity = MATURITY_STABLE;
$plugin->release = 'v1.0';

2. install.xml (estructura de base de datos)

Ubicado en db/install.xml. Define la tabla del plugin.


<?xml version="1.0" encoding="UTF-8" ?>
<XMLDB PATH="mod/mimodulo/db" VERSION="2025042500"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:noNamespaceSchemaLocation="../../lib/xmldb/xmldb.xsd">

    <TABLES>
        <TABLE NAME="mimodulo" COMMENT="Tabla del módulo mimodulo">
            <FIELDS>
                <FIELD NAME="id" TYPE="int" LENGTH="10" NOTNULL="true" SEQUENCE="true"/>
                <FIELD NAME="name" TYPE="char" LENGTH="255" NOTNULL="true"/>
                <FIELD NAME="timecreated" TYPE="int" LENGTH="10" NOTNULL="true"/>
                <FIELD NAME="timemodified" TYPE="int" LENGTH="10" NOTNULL="false"/>
            </FIELDS>
            <KEYS>
                <KEY NAME="primary" TYPE="primary" FIELDS="id"/>
            </KEYS>
        </TABLE>
    </TABLES>
</XMLDB>
2.5 access.php
<?php
defined('MOODLE_INTERNAL') || die();

$capabilities = [
    'mod/mimodulo:addinstance' => [
        'captype' => 'write',
        'contextlevel' => CONTEXT_COURSE,
        'archetypes' => ['editingteacher' => CAP_ALLOW, 'manager' => CAP_ALLOW],
    ],
];

3. lang/en/mimodulo.php

Define los textos visibles.

<?php
$string['pluginname'] = 'Mi Módulo';
$string['modulename'] = 'Mi Módulo';
$string['modulenameplural'] = 'Mis Módulos';
$string['mimodulo:addinstance'] = 'Agregar una nueva instancia de Mi Módulo';
$string['name'] = 'Nombre del módulo';

4. mod_form.php

Formulario que se muestra al crear o editar la actividad.


<?php

require_once($CFG->dirroot . '/course/moodleform_mod.php');

class mod_mimodulo_mod_form extends moodleform_mod {

    function definition() {
        $mform = $this->_form;

        $mform->addElement('text', 'name', get_string('name', 'mimodulo'), ['size' => '64']);
        $mform->setType('name', PARAM_TEXT);
        $mform->addRule('name', null, 'required', null, 'client');

        $this->standard_coursemodule_elements();
        $this->add_action_buttons();
    }
}

5. lib.php

Contiene funciones principales del módulo.


<?php

function mimodulo_add_instance($data, $mform) {
    global $DB;
    $data->timecreated = time();
    return $DB->insert_record('mimodulo', $data);
}

function mimodulo_update_instance($data, $mform) {
    global $DB;
    $data->timemodified = time();
    $data->id = $data->instance;
    return $DB->update_record('mimodulo', $data);
}

function mimodulo_delete_instance($id) {
    global $DB;
    return $DB->delete_records('mimodulo', ['id' => $id]);
}

6. view.php

Lo que el estudiante verá al ingresar a la actividad.


<?php

require_once('../../config.php');

$id = required_param('id', PARAM_INT);
$cm = get_coursemodule_from_id('mimodulo', $id, 0, false, MUST_EXIST);
$context = context_module::instance($cm->id);

require_login($cm->course, true, $cm);
$PAGE->set_url('/mod/mimodulo/view.php', ['id' => $id]);
$PAGE->set_context($context);
$PAGE->set_title('Mi Módulo');
$PAGE->set_heading('Mi Módulo');

echo $OUTPUT->header();
echo $OUTPUT->heading('Hola, este es tu nuevo módulo en Moodle 🚀');
echo $OUTPUT->footer();

Instalación del plugin

Copia la carpeta mimodulo en moodle/mod/.
Ve a tu Moodle como administrador.
Moodle detectará automáticamente el nuevo plugin.
Sigue el asistente de instalación.
¡Listo! Ya puedes usar tu módulo en cualquier curso.

Prueba tu plugin

Entra a un curso como administrador o profesor.
Activa edición.
Haz clic en “Agregar una actividad o recurso”.
Verás "Mi Módulo" en la lista.
Agrega una instancia y prueba su vista.

Este tutorial te brinda una base sólida para crear tu propio plugin de tipo actividad en Moodle con php. A partir de aquí, puedes expandir la funcionalidad, agregar configuraciones, vistas personalizadas, lógica de calificación y mucho más.

Si te gustó este artículo y te fue útil, ¡compártelo!.

Este tutorial fue creado pensando en los desarrolladores que usan Moodle en Colombia, especialmente en Manizales, donde la tecnología educativa sigue creciendo y conectando comunidades de aprendizaje, el objetivo es de aprendizaje para que puedan aprender a crear un plugin y a partir de esto desarrollar el que requieran a medida.

lunes, 14 de abril de 2025

Lista de los comandos más comunes de Eloquent en Laravel

Creación y guardado de datos


// Crear y guardar
$user = new User;
$user->name = 'Juan';
$user->email = 'juan@example.com';
$user->save();

// Crear directamente
User::create([
    'name' => 'Juan',
    'email' => 'juan@example.com'
]);

Lectura de datos

User::all(); // Obtener todos
User::find(1); // Buscar por ID
User::where('email', 'juan@example.com')->first(); // Primer coincidencia
User::where('active', 1)->get(); // Coincidencias múltiples
User::findOrFail(1); // Lanza 404 si no existe
User::firstOrFail(); // Similar a findOrFail pero sin ID

Actualización de datos

$user = User::find(1);
$user->name = 'Pedro';
$user->save();

// O directamente
User::where('id', 1)->update(['name' => 'Pedro']);

Eliminación de datos

User::destroy(1); // Por ID
User::where('active', 0)->delete(); // Varios
$user = User::find(1);
$user->delete(); // Individual

Consultas avanzadas

User::where('age', '>', 18)->get();
User::orderBy('created_at', 'desc')->get();
User::limit(10)->get();
User::select('id', 'name')->get();
User::whereBetween('age', [18, 30])->get();
User::whereIn('id', [1,2,3])->get();

Relaciones Eloquent

// Uno a muchos
$user->posts; // Relación definida en el modelo

// Muchos a muchos
$user->roles()->attach($roleId);
$user->roles()->sync([1, 2]);
$user->roles()->detach($roleId);

// Cargar relaciones
User::with('posts')->get();

Paginar resultados

User::paginate(10); // Paginación simple
User::simplePaginate(10); // Más ligera

Soft deletes

use Illuminate\Database\Eloquent\SoftDeletes;

User::withTrashed()->get(); // Incluye eliminados
User::onlyTrashed()->get(); // Solo eliminados
$user->restore(); // Restaurar
$user->forceDelete(); // Eliminar permanentemente

Scopes (Alcances personalizados)

// Modelo User
public function scopeActive($query) {
    return $query->where('active', 1);
}

// Uso
User::active()->get();

miércoles, 26 de marzo de 2025

Comandos de Laravel: Guía esencial para desarrolladores

Comandos útiles en Laravel

1. Instalación de Laravel

Para instalar Laravel en tu sistema, usa Composer:

composer create-project --prefer-dist laravel/laravel nombre-del-proyecto

Para iniciar el servidor de desarrollo:

php artisan serve

Esto ejecuta Laravel en http://127.0.0.1:8000.

2. Comandos esenciales de Artisan

Artisan es la herramienta de línea de comandos de Laravel. Puedes ver todos los comandos disponibles con:

php artisan list

Para limpiar cachés y mejorar el rendimiento:

php artisan cache:clear
php artisan config:clear
php artisan route:clear
php artisan view:clear

Si necesitas generar una clave de aplicación:

php artisan key:generate

3. Migraciones y base de datos

Si trabajas con bases de datos, estos comandos te ayudarán:

Crear una migración:

php artisan make:migration nombre_de_la_migracion

Ejecutar las migraciones:

php artisan migrate

Revertir migraciones:

php artisan migrate:rollback

4. Modelos y controladores

Para crear un modelo con su respectiva migración:

php artisan make:model NombreModelo -m

Para generar un controlador:

php artisan make:controller NombreControlador

Si el controlador es de tipo recurso:

php artisan make:controller NombreControlador --resource

5. Seeders y Factories

Para poblar la base de datos con datos de prueba:

php artisan db:seed

Si necesitas generar un nuevo seeder:

php artisan make:seeder NombreSeeder

Para crear una factory:

php artisan make:factory NombreFactory --model=NombreModelo

6. Rutas y middleware

Para listar todas las rutas de la aplicación:

php artisan route:list

Para crear un middleware:

php artisan make:middleware NombreMiddleware

7. Comandos para colas y tareas programadas

Si usas colas en Laravel, puedes ejecutar lo siguiente:

php artisan queue:work

Para programar tareas automáticas:

php artisan schedule:run

8. Pruebas y depuración

Ejecutar pruebas con PHPUnit:

php artisan test

Crear una nueva prueba:

php artisan make:test NombreTest

domingo, 19 de enero de 2025

Escucha Activa 5 formas de Mejorarla!

Escucha Activa 5 formas de Mejorarla:

1. Concentración en el emisor.

2. Sin prejuicios.

3. Aprovechar los silencios.

4. Parafrasear.

5. Evitar el egocentrismo.

martes, 17 de diciembre de 2024

Comandos útiles en mysql shell

Comandos útiles en mysql shell

mysql --version

mysql -u root -p

show databases;

service mysql start

service mysql stop

service mysql restart

martes, 26 de noviembre de 2024

Como configurar globalmente en github

git config --global user.name "user"

git config --global user.email "user@gmail.com"