En este post, te mostraré cómo enviar notificaciones a través de Telegram utilizando Laravel de una forma sencilla y fácil de configurar.

## Pasos a Seguir

### 1. Crear tu Bot en Telegram

1. **Iniciar una Conversación con BotFather**: Ve a Telegram y busca a [@BotFather](https://core.telegram.org/bots#6-botfather).
2. **Crear un Nuevo Bot**: Usa el comando `/newbot` y sigue las instrucciones.
   
   ```plaintext
   /newbot
   ```

3. **Asignar un Nombre**: Elige un nombre único para tu bot, como `mysuperbot9000_bot`. Debe terminar con `_bot`.
4. **Obtener el Token**: Recibirás un token parecido a `1234567890:AAG2eDLduCRjsgHlms1EezWoCqBlpsSJexE`. Guárdalo de forma segura, ya que lo necesitarás más adelante.

### 2. Configurar Laravel

1. **Instalar el Paquete Necesario**: Utiliza Composer para instalar "Telegram Notifications Channel for Laravel".

   ```bash
   composer require laravel-notification-channels/telegram
   ```

2. **Configurar el Token**: Añade el token recibido en el archivo `config/services.php`.

   > **Nota**: Solo sigue estos dos primeros pasos del repositorio. Los demás pasos no son necesarios para nuestro enfoque que utiliza un webhook.

### 3. Agregar `telegram_user_id` al Usuario

1. **Editar al migración de usuario o Crear Migración**: Agrega la columna `telegram_user_id` a la tabla de usuarios. Por ejemplo:

   ```php
   // database/migrations/2014_10_12_000000_create_users_table.php
   public function up(): void
   {
       Schema::create('users', function (Blueprint $table) {
           // Resto de las columnas…
           $table->string('telegram_user_id')->nullable();
       });
   }
   ```

### 4. Crear el Controlador para el Webhook

1. **Manejo de Mensajes de Telegram**: El controlador procesará los mensajes recibidos, extrayendo el ID de usuario de Telegram y asociándolo al usuario correspondiente en tu sistema.

```php
<?php

declare(strict_types=1);

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Contracts\Encryption\DecryptException;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;

class TelegramBotWebhookController extends Controller
{
    public function __invoke(Request $request)
    {
        // Extrae el texto del mensaje recibido del webhook de Telegram
        $message = Arr::get($request->all(), 'message.text');

        // Extrae el ID del usuario de Telegram que envía el mensaje
        $telegramUserId = Arr::get($request->all(), 'message.from.id');

        // Extrae el código después del comando '/start' y lo limpia de espacios
        $code = trim(Arr::get(explode('/start', $message ?? ''), 1, ''));

        // Si no hay código o el ID de Telegram es nulo, termina la ejecución
        if (strlen($code) === 0 || $telegramUserId === null) {
            return ['success' => true];
        }

        try {
            // Intenta desencriptar el código recibido
            $decryptedCode = decrypt($code);

            // Verifica si el código desencriptado cumple con el formato 'code:{idusuario}'
            if (preg_match('/^code:(\d+)$/', $decryptedCode, $matches)) {
                // Extrae el ID del usuario del código
                $userId = $matches[1];

                // Busca el usuario en la base de datos usando el ID extraído
                $user = User::find($userId);

                // Si encuentra el usuario, asigna el ID de Telegram y guarda el cambio
                if ($user !== null) {
                    $user->telegram_user_id = $telegramUserId;
                    $user->save();
                }
            }
        } catch (DecryptException $e) {
            // En caso de error en la desencriptación, no realiza ninguna acción
            // (puede agregar un manejo de errores personalizado aquí si lo desea)
        }

        // Devuelve una respuesta de éxito
        return ['success' => true];
    }
}

```

2. **Ruta en Laravel**: Agrega una ruta para el webhook en `routes/web.php`.

```php
use App\Http\Controllers\TelegramBotWebhookController;
// ...resto de las rutas
Route::post('telegram/webhook', TelegramBotWebhookController::class)->name('telegram.webhook');
```

3. **Excluir de CSRF**: En `app/Http/Middleware/VerifyCsrfToken.php`, añade la ruta del webhook a las excepciones.

```php
class VerifyCsrfToken extends Middleware
{
    protected $except = [
		// Agregar esto:
        'telegram/webhook',
    ];
}
```

### 5. Configurar el Webhook en Telegram

1. **Crear Comando en Laravel**: Crea un comando que configure el webhook para tu bot de Telegram.

```php
<?php
<?php

declare(strict_types=1);

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Http;
use NotificationChannels\Telegram\Telegram;

class ConfigureTelegramWebhoook extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'notifications:set-telegram-webhoook';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Set the Telegram webhook for the bot';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $telegram = app(Telegram::class);

		// La clase `Telegram` no tiene un método para configurar el webhook así que solo
		// lo usaremos para obtener la api url y el token
        $apiUri = sprintf('%s/bot%s/%s', $telegram->getApiBaseUri(), $telegram->getToken(), 'setWebhook');

        Http::post($apiUri, [
            'url' => route('telegram.webhook'),
        ]);

        $this->info(sprintf('Telegram webhook configured to %s !', route('telegram.webhook')));
    }
}

```

**Nota**: Asegúrate de que la ruta del webhook sea accesible públicamente. Si estás trabajando localmente, herramientas como [expose](https://expose.dev/) pueden ser útiles.

2. Corre el comando que recien creaste `php artisan notifications:set-telegram-webhoook`

3. Si todo funciona correctamente, deberías poder ver que el `telegram_user_id` se asigna correctamente en tu base de datos.

### 6. Probar el Webhook

1. **Generar Código Encriptado**: Utiliza `php artisan tinker` para generar un código encriptado que asocie un ID de usuario con tu bot (en un aplicación real probablemente generaras esté código y se lo darás al usuario para que lo copie).

```bash
encrypt('code:1') // Reemplaza '1' con el ID de usuario deseado
```

2. **Enviar Mensaje al Bot**: Usa el código generado para enviar un mensaje a tu bot con el formato `/start {codigo_encriptado}`.

Ejemplo:
```plain
start eyJpdiI6Im1iZzNVZkxUTlMxUGVESlNmdkE0bFE9PSIsInZhbHVlIjoiSDBoVytqOWxuZUNvZjJzaEZEY3paRjJGcmxNYkF2a2x5Q0tteW9vejJ1OD0iLCJtYWMiOiI4ZDU3Mzg0OGQ0YmMwOTM3MzMxMTI1Y2E1OGI2ODFlNTJlM2E0NjdmMzFlMjAwMGVlMDVkZmM5ZDZmYTVhZTJkIiwidGFnIjoiIn0=
```

### 7. Enviar una Notificación de Prueba

1. **Crear una Notificación**: Usa la siguiente notificación de ejemplo para probar que recibes mensajes.

```php
<?php

declare(strict_types=1);

namespace App\Notifications;

use App\Enums\NotificationChannelEnum;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
use NotificationChannels\Telegram\TelegramMessage;

class TestNotification extends Notification implements ShouldQueue
{
    use Queueable;


    /**
     * Get the notification's delivery channels.
     *
     * @return array<int, string>
     */
    public function via(User $notifiable): array
    {
        return ['telegram'];

    }

    public function toTelegram(User $notifiable)
    {
	    // Contenido con formato markdown
        $content = sprintf("*%s*\n\n%s", 'Test notification!', 'If you see this message, it means that your notification was sent successfully.');

        return TelegramMessage::create()
            ->to($notifiable->telegram_user_id)
            ->content($content);
    }
}

```

2. **Probar la Notificación**: En la consola de Laravel, envía una notificación de prueba.

 `php artisan tinker`

```bash
User::find(1)->notifyNow(new App\Notifications\TestNotification())
```

Deberías de recibir una notificación de parte de tu bot en Telegram.

Enviar Notificaciones en Telegram con Laravel, la Forma Fácil

Para ejecutar automáticamente el comando "pint" de Laravel en VS Code al guardar archivos PHP, sigue estos pasos:

1. Instala la extensión "Run on Save" de "emeraldwalk" desde el [Marketplace de Extensiones de VS Code](https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave).

2. Configura la extensión para correr el comando `pint` cada vez que guardas un archivo php en  `settings.json`:

```json
   "emeraldwalk.runonsave": {
	  "commands": [
		{
		  "match": "\\.php$",
		  "cmd": "${workspaceFolder}/vendor/bin/pint ${file}"
		}
	  ]
	}
```

3. Abre un archivo PHP en tu proyecto de Laravel, realiza un cambio y guárdalo (`Ctrl+S`).

4. Observa la salida del comando `php artisan pint` en la terminal en la parte inferior de la ventana de VS Code.

Corre Laravel Ping al guardar un archivo PHP con VS Code

En este breve tutorial, te mostraré cómo listar las ramas recientes de GitHub en tu terminal utilizando un comando sencillo, y cómo crear un alias para ese comando que te permitirá ahorrar tiempo y optimizar tu flujo de trabajo.

### Listar las ramas recientes de GitHub

Para listar las 20 ramas más recientes en tu repositorio local, ingresa el siguiente comando en tu terminal:

```console
git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'
```
*Este comando mostrará las 20 ramas más recientes, ordenadas por la fecha del commit en orden descendente.*


### Crear un alias para el comando

Para hacer el proceso aún más eficiente, puedes crear un alias para el comando. Agrega la siguiente línea a tu archivo de configuración de shell `.bashrc`, `.zshrc` u otro archivo relevante:

```console
alias rb="git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'"
```

Después de guardar los cambios en el archivo de configuración, reinicia tu terminal o ejecuta el comando `source ~/.bashrc`. A partir de ahora, podrás listar tus ramas recientes utilizando el alias `rb`.

Listar ramas recientes de Git en la terminal.

Cuando trabajas con componentes de React, es importante definir las props que un componente puede aceptar. Sin embargo, definir cada prop individualmente para un componente puede volverse tedioso y resultar en mucho código repetitivo.

Una forma de reducir la cantidad de código necesario para definir las props es heredar las props del elemento HTML dentro del componente. Por ejemplo, en lugar de definir todas las props para un elemento `<button>`, puedes heredar las props del elemento HTML y solo definir las "props" personalizadas.

Echemos un vistazo a un componente de ejemplo:

```typescript
interface Props {
  onClick: () => void;
  customProp: boolean;
}

function SomeButton({ customProp = false, onClick }: Props): JSX.Element {
  if (customProp) {
    // hacer algo
  }

  return <button onClick={onClick} />;
}
```

En este ejemplo, el componente `SomeButton` tiene dos props: `onClick` y `customProp`. Si queremos agregar una prop className al botón, no podemos hacerlo porque no la hemos definido en la interfaz Props.

```typescript
// esto no es válido porque no tenemos una prop `className`
<SomeButton customProp onClick={doSomething} className="p-3" />
```

Para resolver este problema, podemos definir las props extendiendo `React.ButtonHTMLAttributes<HTMLButtonElement>`. Esto significa que podemos agregar cualquier prop que acepte un botón regular.

```typescript
interface Props extends React.ButtonHTMLAttributes<HTMLButtonElement> {
  customProp?: boolean;
}

function SomeButton({ customProp = false, ...props }: Props): JSX.Element {
  if (customProp) {
    // hacer algo
  }

  return <button {...props} />;
}
```

Con esta implementación actualizada de `SomeButton`, ahora podemos agregar la prop `className`, junto con cualquier otra prop que acepte un botón regular.

```typescript
// esto funciona
<SomeButton customProp onClick={doSomething} className="p-3" {...anyOtherProp} />
```

Esta técnica se puede aplicar a cualquier elemento HTML en el que se base un componente. Por ejemplo, si el componente se basa en un elemento `<div>`, podemos heredar las props de `React.HTMLAttributes<HTMLDivElement>` en su lugar.

```typescript
interface Props extends React.HTMLAttributes<HTMLDivElement> {
  customProp?: boolean;
}
```

Al heredar props del elemento HTML dentro de un componente, podemos reducir la cantidad de código repetitivo necesario para definir las props, al tiempo que nos permite agregar cualquier prop que acepte el elemento HTML.

Declaraciones eficientes de props en componentes de React.

Si tienes una aplicación de Laravel que programa comandos para que se ejecuten en momentos específicos utilizando el archivo `app/Console/Kernel.php`, es posible que desees agregar una prueba que garantice que el comando fue programado correctamente.

Primero, crea un nuevo archivo de prueba en el directorio de pruebas de tu aplicación de Laravel. En este ejemplo, llamaremos al archivo KernelTest.php y su objetivo será probar que el comando `inspire` se programa para ejecutarse cada hora.

_Nota: Para el ejemplo, estoy utilizando la sintaxis de Pest, pero deberías poder adaptar el código en caso de que utilices phpunit u otro:_

```php
use Illuminate\Console\Scheduling\Event;
use Illuminate\Console\Scheduling\Schedule;

it('schedules the `inspire` command' , function () {
    $schedule = app()->make(Schedule::class);

    $events = collect($schedule->events())->filter(function (Event $event) {
        return stripos($event->command, 'inspire');
    });

    if ($events->count() == 0) {
        $this->fail('No se encontraron eventos');
    }

    $events->each(function (Event $event) {
        $this->assertEquals('0 * * * *', $event->expression);
    });
});
```

En esta prueba, primero obtenemos una instancia de la clase Schedule utilizando la función `app()`. Luego, utilizamos el método `events()` para obtener un array de todos los eventos programados.

Luego, utilizamos el método `filter()` para encontrar cualquier evento cuya propiedad `command` contenga la palabra 'inspire'. Si no se encuentran eventos, fallamos la prueba.

Si se encuentra uno o más eventos, utilizamos el método `each()` para recorrer cada evento y comprobar que la propiedad `expression` esté configurada como `'0 * * * *'`, lo cual indica que el comando está programado para ejecutarse cada hora.

Para ejecutar la prueba, utiliza el siguiente comando:

```console
php artisan test --filter KernelTest
```

Esta prueba debería pasar si el comando inspire se programa para ejecutarse cada hora en la clase Kernel.

¡Eso es todo! Ahora tienes una prueba para asegurarte de que tus comandos programados se estén ejecutando correctamente en tu aplicación de Laravel.

Publicaciones

Enviar Notificaciones en Telegram con Laravel, la Forma Fácil

Corre Laravel Ping al guardar un archivo PHP con VS Code

Listar ramas recientes de Git en la terminal.

Declaraciones eficientes de props en componentes de React.

Prueba que un comando de Laravel está programado