In this post, I will show you how to send notifications via Telegram using Laravel in a simple and easy-to-configure way.

## Steps to Follow

### 1. Create Your Bot in Telegram

1. **Start a Conversation with BotFather**: Go to Telegram and search for [@BotFather](https://core.telegram.org/bots#6-botfather).
2. **Create a New Bot**: Use the `/newbot` command and follow the instructions.
   
   ```plaintext
   /newbot
   ```

3. **Assign a Name**: Choose a unique name for your bot, such as `mysuperbot9000_bot`. It must end with `_bot`.
4. **Get the Token**: You will receive a token similar to `1234567890:AAG2eDLduCRjsgHlms1EezWoCqBlpsSJexE`. Keep it safe, as you will need it later.

### 2. Configure Laravel

1. **Install the Required Package**: Use Composer to install "Telegram Notifications Channel for Laravel".

   ```bash
   composer require laravel-notification-channels/telegram
   ```

2. **Configure the Token**: Add the received token in the `config/services.php` file.

   > **Note**: Only follow these first two steps from the repository. The other steps are not necessary for our approach that uses a webhook.

### 3. Add `telegram_user_id` to the User

1. **Edit the User Migration or Create Migration**: Add the `telegram_user_id` column to the users table. For example:

   ```php
   // database/migrations/2014_10_12_000000_create_users_table.php
   public function up(): void
   {
       Schema::create('users', function (Blueprint $table) {
           // Rest of the columns…
           $table->string('telegram_user_id')->nullable();
       });
   }
   ```

### 4. Create the Controller for the Webhook

1. **Handling Telegram Messages**: The controller will process the messages received, extracting the Telegram user ID and associating it with the corresponding user in your system.

```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)
    {
        // Extracts the text of the message received from the Telegram webhook
        $message = Arr::get($request->all(), 'message.text');

        // Extracts the Telegram user ID who sends the message
        $telegramUserId = Arr::get($request->all(), 'message.from.id');

        // Extracts the code after the '/start' command and cleans it of spaces
        $code = trim(Arr::get(explode('/start', $message ?? ''), 1, ''));

        // If there's no code or the Telegram ID is null, end execution
        if (strlen($code) === 0 || $telegramUserId === null) {
            return ['success' => true];
        }

        try {
            // Tries to decrypt the received code
            $decryptedCode = decrypt($code);

            // Checks if the decrypted code complies with the format 'code:{userid}'
            if (preg_match('/^code:(\d+)$/', $decryptedCode, $matches)) {
                // Extracts the user ID from the code
                $userId = $matches[1];

                // Searches for the user in the database using the extracted ID
                $user = User::find($userId);

                // If the user is found, assigns the Telegram ID and saves the change
                if ($user !== null) {
                    $user->telegram_user_id = $telegramUserId;
                    $user->save();
                }
            }
        } catch (DecryptException $e) {
            // In case of an error in decryption, no action is taken
            // (you can add custom error handling here if you wish)
        }

        // Returns a success response
        return ['success' => true];
    }
}

```

2. **Route in Laravel**: Add a route for the webhook in `routes/web.php`.

```php
use App\Http\Controllers\TelegramBotWebhookController;
// ...rest of the routes
Route::post('telegram/webhook', TelegramBotWebhookController::class)->name('telegram.webhook');
```

3. **Exclude from CSRF**: In `app/Http/Middleware/VerifyCsrfToken.php`, add the webhook route to the exceptions.

```php
class VerifyCsrfToken extends Middleware
{
    protected $except = [
        // Add this:
        'telegram/webhook',
    ];
}
```

### 5. Configure the Webhook in Telegram

1. **Create Command in Laravel**: Create a command that sets up the webhook for

 your Telegram bot.

```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);

        // The `Telegram` class doesn't have a method to set the webhook so we will just
        // use it to get the api url and the 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')));
    }
}

```

**Note**: Make sure the webhook route is publicly accessible. If you're working locally, tools like [expose](https://expose.dev/) can be helpful.

2. Run the command you just created `php artisan notifications:set-telegram-webhoook`

3. If everything works correctly, you should be able to see that the `telegram_user_id` is correctly assigned in your database.

### 6. Test the Webhook

1. **Generate Encrypted Code**: Use `php artisan tinker` to generate an encrypted code that associates a user ID with your bot (in a real application you would probably generate this code and give it to the user to copy).

```bash
encrypt('code:1') // Replace '1' with the desired user ID
```

2. **Send Message to the Bot**: Use the generated code to send a message to your bot in the format `/start {encrypted_code}`.

Example:
```plain
start eyJpdiI6Im1iZzNVZkxUTlMxUGVESlNmdkE0bFE9PSIsInZhbHVlIjoiSDBoVytqOWxuZUNvZjJzaEZEY3paRjJGcmxNYkF2a2x5Q0tteW9vejJ1OD0iLCJtYWMiOiI4ZDU3Mzg0OGQ0YmMwOTM3MzMxMTI1Y2E1OGI2ODFlNTJlM2E0NjdmMzFlMjAwMGVlMDVkZmM5ZDZmYTVhZTJkIiwidGFnIjoiIn0=
```

### 7. Send a Test Notification

1. **Create a Notification**: Use the following example notification to test that you receive messages.

```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)
    {
        // Content with markdown formatting
        $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. **Test the Notification**: In the Laravel console, send a test notification.

 `php artisan tinker`

```bash
User::find(1)->notifyNow(new App\Notifications\TestNotification())
```

You should receive a notification from your bot on Telegram.

Sending Notifications on Telegram with Laravel, the Easy Way

To automatically run laravel pint in VS Code when saving PHP files, follow these steps:

1. Install the `emeraldwalk` ["Run on Save"](https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave) extension from the VS Code Extensions Marketplace.

2. In your `settings.json` file, Configure the "Run on Save" extension to run the pint command every time you save a PHP file :
   
```json
   "emeraldwalk.runonsave": {
	  "commands": [
		{
		  "match": "\\.php$",
		  "cmd": "${workspaceFolder}/vendor/bin/pint ${file}"
		}
	  ]
	}
```

3. Open a PHP file in your Laravel project, make a change, and save it (`Ctrl+S`).

4. Witness the `php artisan pint` command's output in the terminal at the bottom of the VS Code window.

Run Laravel Pint on Save with VS Code

In this quick tutorial, we'll show you how to list the recent GitHub branches in your terminal using a simple command, and how to create an alias for that command to save time and streamline your workflow.

### Listing Recent GitHub Branches

To list the 20 most recent branches in your local repository, enter the following command in your terminal:

```console
git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'
```
*This command will display the 20 most recent branches, sorted by the commit date in descending order.*


### Creating an Alias for the Command

To make the process even more efficient, you can create an alias for the command. Add the following line to your `.bashrc`, `.zshrc`, or other relevant shell configuration file:

```console
alias rb="git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'"
```

After saving the changes to the configuration file, restart your terminal or run source ~/.bashrc, from now on you should be able to list your recent branches using the alias `rb`

List Recent GitHub Branches in Terminal

When working with React components, it's important to define the props a component can accept. However, defining every single prop for a component can become tedious and result in a lot of boilerplate code.

One way to reduce the amount of code needed to define props is to inherit props from the HTML element inside the component. For example, instead of defining all the props for a `<button>` element, you can inherit the props from the HTML element and only define the "custom" ones.

Let's take a look at an example component:

```typescript
interface Props {
  onClick: () => void;
  customProp: boolean;
}

function SomeButton({ customProp = false, onClick }: Props): JSX.Element {
  if (customProp) {
    // do something
  }

  return <button onClick={onClick} />;
}
```

In this example, the `SomeButton` component has two props: `onClick` and `customProp`. If we want to add a className prop to the button, we can't do so because we did not define it in the Props interface.

```typescript
// this is not valid because we don't have a `className` prop
<SomeButton customProp onClick={doSomething} className="p-3" />
```

To solve this problem, we can define the props by extending `React.ButtonHTMLAttributes<HTMLButtonElement>`. This means that we can add any prop that a regular button accepts.

```typescript
interface Props extends React.ButtonHTMLAttributes<HTMLButtonElement> {
  customProp?: boolean;
}

function SomeButton({ customProp = false, ...props }: Props): JSX.Element {
  if (customProp) {
    // do something
  }

  return <button {...props} />;
}
```

With this updated implementation of `SomeButton`, we can now add the `className` prop, along with any other prop that a regular button accepts.

```typescript
// this works
<SomeButton customProp onClick={doSomething} className="p-3" {...anyOtherProp} />
```

This technique can be applied to any HTML element that a component is based on. For example, if the component is based on a `<div>` element, we can inherit props from `React.HTMLAttributes<HTMLDivElement>` instead.

```typescript
interface Props extends React.HTMLAttributes<HTMLDivElement> {
  customProp?: boolean;
}
```

By inheriting props from the HTML element inside a component, we can reduce the amount of boilerplate code needed to define props, while still allowing us to add any prop that the HTML element accepts.

Efficient Prop Declarations in React Components

If you have a Laravel application that schedules commands to run at specific times using the `app/Console/Kernel.php` file, you may want to add a test that ensures that the scheduled command is running correctly.

First, create a new test file in the tests directory of your Laravel application. In this example, we'll call the file KernelTest.php and the purpose is to test that the `inspire` command is scheduled to run every hour.

_Note: For the example I am using the phppest syntax but you should be able to adapt the code in case you use the built-in syntax:_

```php
use Illuminate\Console\Scheduling\Event;
use Illuminate\Console\Scheduling\Schedule;

it('schedules the `inspire` command correctly', 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 events found');
    }

    $events->each(function (Event $event) {
        $this->assertEquals('0 * * * *', $event->expression);
    });
});
```

In this test, we first get an instance of the Schedule class using the app function. We then use the events method to get an array of all scheduled events.

We then use the filter method to find any events that have the command property containing the word 'inspire'. If no events are found, we fail the test.

If one or more events are found, we use the each method to loop through each event and assert that the expression property is set to `'0 * * * *'`, which indicates that the command is scheduled to run every hour.

To run the test, use the following command:

```console
php artisan test --filter KernelTest
```

This test should pass if the inspire command is scheduled to run every hour in the Kernel class.

That's it! You now have a test to ensure that your scheduled commands are running correctly in your Laravel application.

Posts

Sending Notifications on Telegram with Laravel, the Easy Way

Run Laravel Pint on Save with VS Code

List Recent GitHub Branches in Terminal

Efficient Prop Declarations in React Components

Test that a laravel command is scheduled