DEV Community: Akram Ghaleb

How to Create a Telegram Bot and Send Messages Using Laravel 12

Akram Ghaleb — Tue, 14 Oct 2025 14:06:17 +0000

How to Create a Telegram Bot and Send Messages Using Laravel 12

In this blog we will discover how to create a Telegram bot and seamlessly integrate it with Laravel 12 in this comprehensive guide. Learn step-by-step instructions on obtaining your API token, setting up the irazasyed/telegram-bot-sdk, and sending messages directly to your bot. Whether you're a beginner or an experienced developer, this tutorial provides all the essential information you need to enhance your applications with Telegram's messaging capabilities. Start building interactive and engaging experiences for your users today!

Step 1: Create Your Telegram Bot

Open Telegram: Launch the Telegram app on your device or access the web version.
Find the BotFather: In the search bar, type @BotFather and select the official BotFather bot. This bot is responsible for creating and managing other bots.
Start a Chat: Click on the "Start" button or type /start to initiate the conversation with BotFather.
Create a New Bot: Use the command /newbot to create a new bot. BotFather will ask you to choose a name and a username for your bot:

Name: This is the display name of your bot (e.g., "My Awesome Bot").
Username: This must be unique and should end with the word "bot" (e.g., "myawesome_bot").

Get Your API Token: Once your bot is created, BotFather will provide you with an API token. It looks something like this:

Example:

   123456789:ABCdefGhIJKlmNoPQRstUvWxYz1234567890

Save this token, as you will need it to connect your Laravel application to your bot.

Step 2: Set Up Laravel 12

2.1 Create a new laravel project

Creating a new project by running the following command:

composer create-project laravel/laravel laravel-telegram-bot

2.2 Install the Telegram Bot SDK

Next, install the irazasyed/telegram-bot-sdk package using Composer:

composer require irazasyed/telegram-bot-sdk

2.3 Configure the SDK

After installing the SDK, publish the configuration file:

php artisan vendor:publish --tag="telegram-config"

This command creates a configuration file located at config/telegram.php.

2.4 Set the Bot Token in `.env`

Open your .env file and add your Telegram bot token:

TELEGRAM_BOT_TOKEN=123456789:ABCdefGhIJKlmNoPQRstUvWxYz1234567890

Step 3: Sending a Message to Your Bot

Now that your bot is set up and configured, let's create a route to send messages to your bot.

3.1 Create a Route

Open the routes/web.php file and add the following route:

use Telegram\Bot\Laravel\Facades\Telegram;

Route::get('/send-message', function () {
    $chatId = 'YOUR_CHAT_ID'; // Replace with your chat ID
    $message = 'Hello, this is a message from Laravel!';

    Telegram::sendMessage([
        'chat_id' => $chatId,
        'text' => $message,
    ]);

    return 'Message sent to Telegram!';
});

3.2 Get Your Chat ID

To send messages to your chat, you need to know your chat_id. To find this, you can use the getUpdates method.

Add another route to routes/web.php:

Route::get("/get-updates", function () {
  $updates = Telegram::getUpdates();
  return $updates;
});

3.3 Test Sending a Message

Now, visit http://127.0.0.1:8000/send-message in your browser, replacing 127.0.0.1:8000 with your actual application URL. You should see a message saying "Message sent to Telegram!" and receive the message in your Telegram chat.

Conclusion

You’ve successfully created a Telegram bot, obtained an API token, and integrated it into your Laravel 12 application using the irazasyed/telegram-bot-sdk. Now you can build more complex interactions with your bot or expand its capabilities.

For further exploration, consider adding features like handling incoming messages, setting up command handlers, or integrating with other services. The possibilities with Telegram bots are endless!

A Practical Guide to Deferred Props in Inertia 2

Akram Ghaleb — Wed, 15 Jan 2025 17:55:42 +0000

Inertia 2 introduced a powerful feature called Deferred Props, which allows you to delay the loading of non-critical data until it’s needed. This can significantly improve the performance of your application by reducing the initial payload size and speeding up page load times. In this guide, we’ll explore how to use Deferred Props with practical examples.

What Are Deferred Props?

Deferred Props allow you to prioritize critical data and defer non-critical data, loading it only when explicitly requested. This is particularly useful for:

Improving initial page load times: By reducing the amount of data sent upfront, your application loads faster.
Optimizing performance: Deferring non-essential data reduces the payload size and improves overall performance.
Simplifying code: You can avoid cluttering your components with unnecessary data fetching logic.

Example 1: Deferring Data in the Backend

Let’s start with a backend example. Suppose you have a /courses route where you want to display a list of courses and related topics. However, fetching all the data at once might slow down the initial page load. With Deferred Props, you can prioritize critical data and defer non-critical data.

Here’s how you can implement this in your controller:

use Inertia\Inertia;
use Inertia\Deferred;
use App\Models\Course;
use App\Models\Topic;

class CourseController extends Controller
{
    public function index()
    {
        return Inertia::render('Courses/Index', [
            'courses' => new Deferred(function () {
                sleep(5); // Simulate a slow query
                return Course::all();
            }, 'low'), // Low priority

            'topics' => new Deferred(function () {
                sleep(2); // Simulate a faster query
                return Topic::all();
            }, 'high'), // High priority
        ]);
    }
}

Explanation:

courses: This data is deferred with a low priority, meaning it will be loaded only when explicitly requested.
topics: This data is deferred with a high priority, meaning it will be loaded sooner than courses but still after the critical data.

Example 2: Handling Deferred Props in the Frontend

Now that we’ve deferred the data in the backend, let’s see how to handle it in the frontend. In this example, we’ll use Vue.js to display the deferred topics data and courses data in the frontend.

<template>
  <div>
    <h1>Courses</h1>

    <!-- Display deferred courses -->
    <Deferred :data="courses">
      <template #fallback>
        <LoadingSpinner /> <!-- Show a spinner while loading -->
      </template>

      <template #default>
        <CourseCard
          v-for="course in courses"
          :key="course.id"
          :course="course"
        />
      </template>
    </Deferred>

    <!-- Display deferred topics -->
    <Deferred :data="topics">
      <template #fallback>
        <LoadingSpinner /> <!-- Show a spinner while loading -->
      </template>

      <template #default>
        <TopicCard
          v-for="topic in topics"
          :key="topic.id"
          :topic="topic"
        />
      </template>
    </Deferred>
  </div>
</template>

<script>
export default {
  props: {
    courses: Array,
    topics: Array,
  },
};
</script>

Explanation:

<Deferred>: This component is used to handle deferred data. It automatically fetches the data when needed.
#fallback: This slot is used to display a loading spinner (or any fallback UI) while the data is being fetched.
#default: This slot is used to render the actual data once it’s loaded.

Benefits of Using Deferred Props

Improved Performance: By deferring non-critical data, you reduce the initial payload size, resulting in faster page loads.
Better User Experience: Users see the most important content first, while non-critical data is loaded in the background.
Efficient Resource Usage: Only load data when it’s needed, reducing unnecessary server load and bandwidth usage.

Conclusion

Deferred Props in Inertia 2 are a game-changer for optimizing the performance of your applications. By deferring non-critical data, you can ensure that your app loads quickly and efficiently, providing a better experience for your users.

The examples above demonstrate how to implement Deferred Props in both the backend and frontend. Give it a try in your next project and see the difference it makes!

Resources

A Practical Guide to API Documentation in Laravel with Scribe

Akram Ghaleb — Sun, 05 Jan 2025 19:31:23 +0000

Introduction
What is Laravel Scribe?
Installation
Configuration
Generating Documentation
Customizing Documentation
Conclusion

Introduction

Imagine you’ve just finished developing a REST API for a project. The next step? Documenting your endpoints. Manual documentation can be tedious, error-prone, and time-consuming. Enter Scribe—an amazing Laravel package that generates API documentation automatically.

What this post covers:

Why Scribe is useful.
How to install, configure, and use it.
Practical examples of real-world usage.

What is Laravel Scribe?

Laravel Scribe is a package that automatically generates API documentation from your Laravel routes. It extracts information from your controllers, form requests, and other components to create detailed documentation. This documentation includes endpoints, request parameters, response examples, and more.

Installation

To get started with Laravel Scribe, you need to install it via Composer. Run the following command in your terminal:

composer require --dev knuckleswtf/scribe

After installing the package, you can publish the configuration file using:

php artisan vendor:publish --tag=scribe-config

This will create a scribe.php configuration file in your config directory.

Configuration

The scribe.php configuration file allows you to customize various aspects of your API documentation. Some key configurations include:

title: The title of your API documentation.
description: A brief description of your API.
base_url: The base URL for your API.
routes: Define which routes should be included in the documentation.

Here's an example configuration:

return [
    'title' => 'My API Documentation',
    'description' => 'This is the API documentation for My Application.',
    'base_url' => env('APP_URL'),
    'routes' => [
        [
            'match' => [
                'prefixes' => ['api/*'],
            ],
            'include' => [],
            'exclude' => [],
        ],
    ],
];

Generating Documentation

Once you've configured Laravel Scribe, you can generate the documentation by running:

php artisan scribe:generate

This command will create a set of static HTML files in the public/docs directory by default. You can access the documentation by navigating to http://your-app-url/docs.

Customizing Documentation

Laravel Scribe allows you to customize the documentation by adding annotations to your controllers and methods. Here are some common annotations:

@group: Groups related endpoints together.
@bodyParam: Describes a request body parameter.
@response: Provides an example response.

Here's an example of a controller method with annotations:

/**
 * @group User Management
 *
 * Register a new user.
 *
 * @bodyParam name string required The name of the user. Example: Akram Ghaleb
 * @bodyParam email string required The email of the user. Example: akram@example.com
 * @bodyParam password string required The password of the user. Example: password123
 *
 * @response 200 {
 *     "message": "User registered successfully",
 *     "user": {
 *         "id": 1,
 *         "name": "Akram Ghaleb",
 *         "email": "akram@example.com"
 *     }
 * }
 */
public function register(Request $request)
{
    // Registration logic here
}

Conclusion

Laravel Scribe is an invaluable tool for generating API documentation in Laravel applications. It simplifies the process, ensures consistency, and provides a professional-looking documentation interface. By following the steps outlined in this blog post, you can easily integrate Laravel Scribe into your project and create comprehensive API documentation.

Happy coding 🚀

3 Steps to Speed Up Laravel Projects with Laravel Shift Blueprint

Akram Ghaleb — Tue, 12 Nov 2024 10:03:42 +0000

If you’re looking to cut down on repetitive coding tasks and get your Laravel projects off the ground faster, Laravel Shift Blueprint is the tool for you! Here’s a streamlined guide on how to use Blueprint effectively in three easy steps.

1. Install Blueprint

To get started, install Blueprint in your development environment using Composer:

composer require --dev laravel-shift/blueprint

Blueprint is a development-only package, so it’s best to install it with the --dev flag. This ensures it won’t be included in your production environment, keeping your deployment lean and clean.

2. Create the `draft.yaml` File

The draft.yaml file is the heart of Blueprint—it’s where you define your models, controllers, relationships, and even routes! Start by creating a draft.yaml file in your project’s root directory.

Blueprint reads this file to understand the structure of your app. Here’s a sample setup for a blog:

models:
  Post:
    title: string
    content: text
    published_at: timestamp nullable
    status: string
    category_id: unsignedInteger nullable
    relationships:
      belongsTo: Category
      belongsToMany: Tag, Author

  Category:
    name: string
    description: string nullable
    relationships:
      hasMany: Post

  Author:
    name: string
    email: string
    bio: text nullable
    twitter_handle: string nullable
    relationships:
      belongsToMany: Post

  Tag:
    name: string
    slug: string
    relationships:
      belongsToMany: Post

This simple YAML file defines multiple models, fields, and relationships in one place, allowing you to model your entire app’s data structure with minimal syntax.

3. Generate Code with Blueprint

Once you’ve defined your models in draft.yaml, it’s time to let Blueprint work its magic. Run the following command to generate your code:

php artisan blueprint:build

This command reads draft.yaml and automatically generates models, migrations, controllers, and routes based on your specifications. You’ll see files created for each model and relationship, saving you from writing boilerplate code manually.

Bonus Tips for Optimizing Your Workflow

Add Custom Attributes and Relationships: You can always modify draft.yaml to include more attributes or complex relationships as your app grows. For example, add unique constraints, nullable fields, and foreign keys.
Regenerate on the Fly: Blueprint is not a one-time tool. As your app evolves, update your draft.yaml file and re-run php artisan blueprint:build. This will adjust your models, migrations, and other components without overwriting custom code you’ve already modified.
Define Requests, Factories, and Controllers: Blueprint also supports defining form requests, factories, and custom controllers to help structure your application behavior in draft.yaml. This further speeds up development and maintains clean, well-organized code.

Give Laravel Shift Blueprint a try, and see how it can transform your Laravel workflow, helping you build features faster and more efficiently.

Happy coding! 🚀

How to Create a Telegram Bot and Send Messages Using Laravel 11

Akram Ghaleb — Fri, 04 Oct 2024 13:59:32 +0000

In this blog we will discover how to create a Telegram bot and seamlessly integrate it with Laravel 11 in this comprehensive guide. Learn step-by-step instructions on obtaining your API token, setting up the irazasyed/telegram-bot-sdk, and sending messages directly to your bot. Whether you're a beginner or an experienced developer, this tutorial provides all the essential information you need to enhance your applications with Telegram's messaging capabilities. Start building interactive and engaging experiences for your users today!

Step 1: Create Your Telegram Bot

Open Telegram: Launch the Telegram app on your device or access the web version.
Find the BotFather: In the search bar, type @BotFather and select the official BotFather bot. This bot is responsible for creating and managing other bots.
Start a Chat: Click on the "Start" button or type /start to initiate the conversation with BotFather.
Create a New Bot: Use the command /newbot to create a new bot. BotFather will ask you to choose a name and a username for your bot:
- Name: This is the display name of your bot (e.g., "My Awesome Bot").
- Username: This must be unique and should end with the word "bot" (e.g., "myawesome_bot").
Get Your API Token: Once your bot is created, BotFather will provide you with an API token. It looks something like this:

Example:

123456789:ABCdefGhIJKlmNoPQRstUvWxYz1234567890

Save this token, as you will need it to connect your Laravel application to your bot.

Step 2: Set Up Laravel 11

2.1 Create a new laravel project

Creating a new project by running the following command:

composer create-project laravel/laravel laravel-telegram-bot

2.2 Install the Telegram Bot SDK

Next, install the irazasyed/telegram-bot-sdk package using Composer:

composer require irazasyed/telegram-bot-sdk

2.3 Configure the SDK

After installing the SDK, publish the configuration file:

php artisan vendor:publish --tag="telegram-config"

This command creates a configuration file located at config/telegram.php.

2.4 Set the Bot Token in `.env`

Open your .env file and add your Telegram bot token:

TELEGRAM_BOT_TOKEN=123456789:ABCdefGhIJKlmNoPQRstUvWxYz1234567890

Step 3: Sending a Message to Your Bot

Now that your bot is set up and configured, let's create a route to send messages to your bot.

3.1 Create a Route

Open the routes/web.php file and add the following route:

use Telegram\Bot\Laravel\Facades\Telegram;

Route::get('/send-message', function () {
$chatId = 'YOUR_CHAT_ID'; // Replace with your chat ID
$message = 'Hello, this is a message from Laravel!';

Telegram::sendMessage([
'chat_id' => $chatId,
'text' => $message,
]);

return 'Message sent to Telegram!';
});

3.2 Get Your Chat ID

To send messages to your chat, you need to know your chat_id. To find this, you can use the getUpdates method.

Add another route to routes/web.php:

Route::get('/get-updates', function () {
$updates = Telegram::getUpdates();
return $updates;
});

3.3 Test Sending a Message

Conclusion

You’ve successfully created a Telegram bot, obtained an API token, and integrated it into your Laravel 11 application using the irazasyed/telegram-bot-sdk. Now you can build more complex interactions with your bot or expand its capabilities.

For further exploration, consider adding features like handling incoming messages, setting up command handlers, or integrating with other services. The possibilities with Telegram bots are endless!

Code Example

https://github.com/akramghaleb/send-telegram-messages-with-laravel-11

Watch the video

laravel-nuxt-template

Akram Ghaleb — Sun, 09 Jun 2024 06:33:40 +0000

This repository provides a starter template for building web applications using Laravel as the backend and Nuxt.js as the frontend framework.

This project built with Laravel 11 + Nuxt 3

This template build with Laravel v11.0 & Nuxt v3.11
This template Support Pinia State Management
If you like this work you can see more here

Features

Technology Stack: This release leverages Laravel version 11.0 for the backend framework and Nuxt version 3.11 for the frontend framework. Laravel provides a robust foundation for developing web applications with its elegant syntax and powerful features, while Nuxt.js enhances the development experience by offering a framework for building server-side rendered Vue.js applications with features like automatic code splitting, hot module replacement, and more.
State Management: The release incorporates Pinia version 2.1 for state management. Pinia is a modern and lightweight state management solution for Vue.js applications. It provides a simple and intuitive API for managing application state, making it easier to organize and manage complex data in Vue.js applications. With Pinia v2.1, developers can take advantage of improved features and optimizations for state management in their applications.
Persisted State: The release introduces support for persisted state, allowing for the storage of application state data in the local storage of the user's browser. This feature ensures that user data persists even after the browser is closed or refreshed, enhancing the user experience by providing continuity and preserving important application data. By leveraging local storage, developers can create more resilient and user-friendly applications that remember user preferences and maintain session state across sessions.

Installation

Clone the repository

git clone https://github.com/akramghaleb/laravel-nuxt-template.git

Switch to the repo folder

cd laravel-nuxt-template

switch to frontend folder (nuxt app)

cd frontend

cp .env.example .env

Make sure to install the dependencies:

# npm
npm install

# pnpm
pnpm install

# yarn
yarn install

# bun
bun install

Build your code:

# npm
npm run generate

# pnpm
pnpm run generate

# yarn
yarn generate

# bun
bun run generate

switch to backend folder (laravel app)

cd ../backend

Install all the dependencies using composer

composer install

Copy the example env file and make the required configuration changes in the .env file

cp .env.example .env

Generate a new application key

php artisan key:generate

Run the database migrations (Set the database connection in .env before migrating)

php artisan migrate

Start the local development server

php artisan serve

You can now access the server at http://localhost:8000

Github Repo

Thanks,

If you enjoy my work, consider buying me a coffee to keep the creativity flowing!

Route Rider System

Akram Ghaleb — Sat, 08 Jun 2024 08:39:09 +0000

This project built with Laravel + Tailwind + Filament

Arabic and English support
Has a landing page
Dashboard support with statistical features
Ability to register & recover passwords
Ability to change theme settings
Support roles and permissions
Support Light & Dark theme
Support Soft delete and recovery tasks
If you like this work you can see more here

Installation

Clone the repository

git clone https://github.com/akramghaleb/Route-Rider-System.git

Install all the dependencies using the composer

composer install

Copy the example env file and make the required configuration changes in the .env file

cp .env.example .env

Generate a new application key

php artisan key:generate

Run the database migrations (Set the database connection in .env before migrating)

php artisan migrate --seed

Make sure to install the dependencies:

# npm
npm install

# pnpm
pnpm install

# yarn
yarn install

# bun
bun install

Build your code:

# npm
npm run build

# pnpm
pnpm run build

# yarn
yarn build

# bun
bun run build

Start the local development server

php artisan serve

You can now access the server at http://localhost:8000

username: admin@admin.com
password: password

Github Repo

Thanks,

If you enjoy my work, consider buying me a coffee to keep the creativity flowing!

Web Screens

Laravel 11 - Building API using Sanctum

Akram Ghaleb — Sat, 08 Jun 2024 07:29:40 +0000

Laravel 11 - Building API using Sanctum - Table of Contents
- Step 1: Install Laravel 11
- Step 2: Install Sanctum API
- Step 3: Sanctum Configuration
- Step 4: Add Blog Migration and Model
- Step 5: Create Eloquent API Resources
- Step 6: Create Controller Files
- Step 7: Create API Routes
- Step 8: Run Laravel App
- Step 9: Check following API

Step 1: Install Laravel 11

Open your terminal and Install new Laravel application

composer create-project laravel/laravel sanctum-api

Switch to the project folder

cd sanctum-api

Step 2: Install Sanctum API

Run the following command to install Sanctum with API

php artisan install:api

Step 3: Sanctum Configuration

In app/Models/User.php, we added the HasApiTokens class of Sanctum

<?php

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;

class User extends Authenticatable
{
    use HasFactory, Notifiable, HasApiTokens;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * Get the attributes that should be cast.
     *
     * @return array<string, string>
     */
    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
        ];
    }
}

Step 4: Add Blog Migration and Model

Run the following command to add Blog migration and model

php artisan make:model Blog -m

After that go to database/migrations and you will find the created migration file

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('blogs', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->longText('detail');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('blogs');
    }
};

Then go to app/Models/Blog.php

<?php

namespace App\Models;

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

class Blog extends Model
{
    use HasFactory;

    protected $fillable = [
        'title', 'detail'
    ];
}

Step 5: Create Eloquent API Resources

Run the following commands to create Blog API Resources

php artisan make:resource BlogResource

Then go to app/Http/Resources/BlogResource.php

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class BlogResource extends JsonResource
{
    // Transform the resource into an array.
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'detail' => $this->detail,
            'created_at' => $this->created_at->format('d/m/Y'),
            'updated_at' => $this->updated_at->format('d/m/Y'),
        ];
    }
}

Step 6: Create Controller Files

Run the following commands to add BaseController & RegisterController & BlogController

php artisan make:controller API/BaseController
php artisan make:controller API/RegisterController
php artisan make:controller API/BlogController

Then go to app/Http/Controllers/API/BaseController.php and add this code

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

class BaseController extends Controller
{
    // success response method
    public function sendResponse($result, $message)
    {
        $response = [
            'success' => true,
            'data'    => $result,
            'message' => $message,
        ];

        return response()->json($response, 200);
    }

    // return error response
    public function sendError($error, $errorMessages = [], $code = 404)
    {
        $response = [
            'success' => false,
            'message' => $error,
        ];

        if(!empty($errorMessages)){
            $response['data'] = $errorMessages;
        }

        return response()->json($response, $code);
    }
}

Now go to app/Http/Controllers/API/BaseController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Auth;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\Validator;

class RegisterController extends BaseController
{
    // Register api
    public function register(Request $request): JsonResponse
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required',
            'email' => 'required|email',
            'password' => 'required',
            'c_password' => 'required|same:password',
        ]);

        if($validator->fails()){
            return $this->sendError('Validation Error.', $validator->errors());
        }

        $input = $request->all();
        $input['password'] = bcrypt($input['password']);
        $user = User::create($input);
        $success['token'] =  $user->createToken('MyApp')->plainTextToken;
        $success['name'] =  $user->name;

        return $this->sendResponse($success, 'User register successfully.');
    }

    // Login api
    public function login(Request $request): JsonResponse
    {
        if(Auth::attempt(['email' => $request->email, 'password' => $request->password])){
            $user = Auth::user();
            $success['token'] =  $user->createToken('MyApp')->plainTextToken;
            $success['name'] =  $user->name;

            return $this->sendResponse($success, 'User login successfully.');
        }
        else{
            return $this->sendError('Unauthorised.', ['error'=>'Unauthorised']);
        }
    }
}

Finally, go to app/Http/Controllers/API/BlogController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Http\Controllers\API\BaseController;
use App\Models\Blog;
use App\Http\Resources\BlogResource;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\Validator;

class BlogController extends BaseController
{
    // Display a listing of the resource.
    public function index(): JsonResponse
    {
        $blogs = Blog::all();

        return $this->sendResponse(BlogResource::collection($blogs), 'Blogs retrieved successfully.');
    }

    // Store a newly created resource in storage.
    public function store(Request $request): JsonResponse
    {
        $input = $request->all();

        $validator = Validator::make($input, [
            'title' => 'required',
            'detail' => 'required'
        ]);

        if($validator->fails()){
            return $this->sendError('Validation Error.', $validator->errors());
        }

        $blog = Blog::create($input);

        return $this->sendResponse(new BlogResource($blog), 'Blog created successfully.');
    }

    // Display the specified resource.
    public function show($id): JsonResponse
    {
        $blog = Blog::find($id);

        if (is_null($blog)) {
            return $this->sendError('Blog not found.');
        }

        return $this->sendResponse(new BlogResource($blog), 'Blog retrieved successfully.');
    }

    // Update the specified resource in storage.
    public function update(Request $request, Blog $blog): JsonResponse
    {
        $input = $request->all();

        $validator = Validator::make($input, [
            'title' => 'required',
            'detail' => 'required'
        ]);

        if($validator->fails()){
            return $this->sendError('Validation Error.', $validator->errors());
        }

        $blog->title = $input['title'];
        $blog->detail = $input['detail'];
        $blog->save();

        return $this->sendResponse(new BlogResource($blog), 'Blog updated successfully.');
    }

    // Remove the specified resource from storage.
    public function destroy(Blog $blog): JsonResponse
    {
        $blog->delete();

        return $this->sendResponse([], 'Blog deleted successfully.');
    }
}

Step 7: Create API Routes

In this step we will create API routes for login, register, and blogs.

Go to routes/api.php

<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\API\RegisterController;
use App\Http\Controllers\API\BlogController;

Route::controller(RegisterController::class)->group(function(){
    Route::post('register', 'register')->name('register');
    Route::post('login', 'login')->name('login');
});

Route::middleware('auth:sanctum')->group( function () {
    Route::apiResource('blogs', BlogController::class);
    Route::get('user', function (Request $request) {
        return $request->user();
    })->name('user');
});

Step 8: Run Laravel App

Run the database migrations (Set the database connection in .env before migrating)

php artisan serve

Start the local development server

php artisan serve

Step 9: Check following API

Now, go to your Postman to check api

Make sure in the details API, we will use the following headers as listed below

'headers' => [
    'Accept' => 'application/json',
    'Authorization' => 'Bearer '.$accessToken,
]

Now you can simply run the above listed URLs as shown in the screenshot below:

Postman

Note: You can download postman file from here

Github Repo

Thanks,

If you enjoy my work, consider buying me a coffee to keep the creativity flowing!

DEV Community: Akram Ghaleb

How to Create a Telegram Bot and Send Messages Using Laravel 12

How to Create a Telegram Bot and Send Messages Using Laravel 12

Step 1: Create Your Telegram Bot

Step 2: Set Up Laravel 12

2.1 Create a new laravel project

2.2 Install the Telegram Bot SDK

2.3 Configure the SDK

2.4 Set the Bot Token in .env

Step 3: Sending a Message to Your Bot

3.1 Create a Route

3.2 Get Your Chat ID

3.3 Test Sending a Message

Conclusion

A Practical Guide to Deferred Props in Inertia 2

What Are Deferred Props?

Example 1: Deferring Data in the Backend

Explanation:

Example 2: Handling Deferred Props in the Frontend

Explanation:

Benefits of Using Deferred Props

Conclusion

Resources

A Practical Guide to API Documentation in Laravel with Scribe

Table of Contents

Introduction

What is Laravel Scribe?

Installation

Configuration

Generating Documentation

Customizing Documentation

Conclusion

3 Steps to Speed Up Laravel Projects with Laravel Shift Blueprint

1. Install Blueprint

2. Create the draft.yaml File

3. Generate Code with Blueprint

Bonus Tips for Optimizing Your Workflow

How to Create a Telegram Bot and Send Messages Using Laravel 11

Step 1: Create Your Telegram Bot

Step 2: Set Up Laravel 11

2.1 Create a new laravel project

2.2 Install the Telegram Bot SDK

2.3 Configure the SDK

2.4 Set the Bot Token in .env

Step 3: Sending a Message to Your Bot

3.1 Create a Route

3.2 Get Your Chat ID

3.3 Test Sending a Message

Conclusion

Code Example

Watch the video

laravel-nuxt-template

This project built with Laravel 11 + Nuxt 3

Features

Installation

Route Rider System

This project built with Laravel + Tailwind + Filament

Installation

Laravel 11 - Building API using Sanctum

Table of Contents

Step 1: Install Laravel 11

Step 2: Install Sanctum API

Step 3: Sanctum Configuration

Step 4: Add Blog Migration and Model

Step 5: Create Eloquent API Resources

Step 6: Create Controller Files

Step 7: Create API Routes

Step 8: Run Laravel App

Step 9: Check following API

2.4 Set the Bot Token in `.env`

2. Create the `draft.yaml` File

2.4 Set the Bot Token in `.env`