पुएर का उपयोग करके लारवेल में वास्तविक समय की सूचनाएं कैसे जोड़ें

लेख का अनुवाद विशेष रूप से "लारवेल" पाठ्यक्रम के छात्रों के लिए तैयार किया गया था




एक आधुनिक वेब उपयोगकर्ता को आवेदन में होने वाली हर चीज के बारे में सूचित किए जाने की उम्मीद है। आप ऐसी वेबसाइट नहीं बनना चाहेंगे, जिसके पास सूचनाओं की एक ड्रॉप-डाउन सूची भी न हो, जो अब न केवल सभी सोशल नेटवर्किंग साइटों पर, बल्कि आम तौर पर इन दिनों हर जगह पाई जा सकती है।

सौभाग्य से, लारवेल और पुशर के साथ, इस कार्यक्षमता का कार्यान्वयन काफी सरल है।

वास्तविक समय सूचनाएँ


एक सकारात्मक उपयोगकर्ता अनुभव प्रदान करने के लिए, सूचनाओं को वास्तविक समय में प्रदर्शित किया जाना चाहिए। एक दृष्टिकोण नियमित रूप से सर्वर को एक AJAX अनुरोध भेजने और नवीनतम सूचनाएँ प्राप्त करने का है, यदि कोई हो।

सबसे अच्छा तरीका वेबस्केट्स की क्षमताओं का उपयोग करना और उन्हें भेजे जाने पर सूचनाएं प्राप्त करना है। यह ठीक वैसा ही है जैसा हम इस लेख में लागू करने जा रहे हैं।

ढकेलनेवाला


पुशर वेब-पॉकेट्स के माध्यम से वेब और मोबाइल अनुप्रयोगों में वास्तविक समय की द्वि-दिशात्मक कार्यक्षमता को एकीकृत करने के लिए एक वेब सेवा है।

इसकी एक बहुत ही सरल API है, लेकिन हम इसे Laravel ब्रॉडकास्टिंग और Laravel Echo के साथ और भी आसान बनाने जा रहे हैं।

इस लेख में, हम एक मौजूदा ब्लॉग में वास्तविक समय की सूचनाएं जोड़ने जा रहे हैं।

परियोजना


प्रारंभ


सबसे पहले, हम एक साधारण Laravel ब्लॉग को क्लोन करते हैं:

git clone   https://github.com/marslan-ali/laravel-blog

फिर हम MySQL डेटाबेस बनाएंगे और डेटाबेस तक एप्लिकेशन एक्सेस देने के लिए पर्यावरण चर सेट करेंगे।

आइए नकल env.exampleमें .envऔर डेटाबेस के साथ जुड़े चर अद्यतन करें।

cp .env.example .envDB_HOST=localhost
DB_DATABASE=homestead
DB_USERNAME=homestead
DB_PASSWORD=secret

अब परियोजना के उपयोग पर निर्भरता स्थापित करते हैं

composer install

और कुछ डेटा के साथ डेटाबेस को पॉप्युलेट करने के लिए माइग्रेशन और पॉप्युलेट कमांड चलाएँ:

php artisan migrate --seed

यदि आप एप्लिकेशन चलाते हैं और जाते हैं /posts, तो आप जनरेट किए गए पोस्ट की सूची देख सकते हैं।

एप्लिकेशन की जांच करें, उपयोगकर्ता को पंजीकृत करें और कुछ संदेश बनाएं। यह एक बहुत ही सरल अनुप्रयोग है, लेकिन यह प्रदर्शन के लिए बहुत अच्छा है।

यूजर्स को सब्सक्राइब करें


हम उपयोगकर्ताओं को एक-दूसरे की सदस्यता लेने का अवसर देना चाहते हैं, इसलिए हमें इसे महसूस करने के लिए उपयोगकर्ताओं के बीच कई-से-कई संबंध बनाने होंगे।

चलो एक धुरी तालिका बनाते हैं जो उपयोगकर्ताओं को उपयोगकर्ताओं से जोड़ता है। आइए एक नया प्रवास करें followers:

php artisan make:migration create_followers_table --create=followers

हमें इस माइग्रेशन में कई फ़ील्ड जोड़ने की आवश्यकता है: user_idउपयोगकर्ता को सब्सक्राइब करने के लिए, और follows_idउस उपयोगकर्ता का प्रतिनिधित्व करने के लिए एक फ़ील्ड जो उन्हें सब्सक्राइब किया गया है।

माइग्रेशन को निम्नानुसार अपडेट करें:

public function up()
{
    Schema::create('followers', function (Blueprint $table) {
        $table->increments('id');
        $table->integer('user_id')->index();
        $table->integer('follows_id')->index();
        $table->timestamps();
    });
}

अब तालिका बनाने के लिए आगे बढ़ते हैं:

php artisan migrate

आइए मॉडल में संबंध विधियां जोड़ें User

// ...

class extends Authenticatable
{
    // ...

    public function followers() 
    {
        return $this->belongsToMany(self::class, 'followers', 'follows_id', 'user_id')
                    ->withTimestamps();
    }

    public function follows() 
    {
        return $this->belongsToMany(self::class, 'followers', 'user_id', 'follows_id')
                    ->withTimestamps();
    }
}

अब जब मॉडल के Userपास आवश्यक संबंध हैं, तो यह followersउपयोगकर्ता के सभी ग्राहकों को followsवापस लौटाता है , और उन सभी को लौटाता है जिन्हें उपयोगकर्ता ने सदस्यता दी है।

हमें कुछ सहायक कार्यों की आवश्यकता होगी जो उपयोगकर्ता को अन्य उपयोगकर्ताओं की सदस्यता लेने की अनुमति देते हैं - followऔर यह जांचने के लिए कि उपयोगकर्ता किसी विशिष्ट उपयोगकर्ता की सदस्यता लेता है या नहीं isFollowing

// ...

class extends Authenticatable
{
    // ...

    public function follow($userId) 
    {
        $this->follows()->attach($userId);
        return $this;
    }

    public function unfollow($userId)
    {
        $this->follows()->detach($userId);
        return $this;
    }

    public function isFollowing($userId) 
    {
        return (boolean) $this->follows()->where('follows_id', $userId)->first(['id']);
    }

}

ठीक। मॉडल तैयार करने के बाद, आपको उपयोगकर्ताओं की एक सूची बनाने की आवश्यकता है।

उपयोगकर्ताओं की एक सूची


आइए आवश्यक मार्गों की पहचान करके शुरू करें।

/...
Route::group(['middleware' => 'auth'], function () {
    Route::get('users', 'UsersController@index')->name('users');
    Route::post('users/{user}/follow', 'UsersController@follow')->name('follow');
    Route::delete('users/{user}/unfollow', 'UsersController@unfollow')->name('unfollow');
});

फिर यह उपयोगकर्ताओं के लिए एक नया नियंत्रक बनाने का समय है:

php artisan make:controller UsersController

हम इसमें एक विधि जोड़ेंगे index:

// ...
use App\User;
class UsersController extends Controller
{
    //..
    public function index()
    {
        $users = User::where('id', '!=', auth()->user()->id)->get();
        return view('users.index', compact('users'));
    }
}

विधि को पेश करने की आवश्यकता है। आइए एक दृश्य बनाएं users.indexऔर इसमें निम्नलिखित मार्कअप डालें:

@extends('layouts.app')

@section('content')
    <div class="container">
        <div class="col-sm-offset-2 col-sm-8">

            <!-- Following -->
            <div class="panel panel-default">
                <div class="panel-heading">
                    All Users
                </div>

                <div class="panel-body">
                    <table class="table table-striped task-table">
                        <thead>
                        <th>User</th>
                        <th> </th>
                        </thead>
                        <tbody>
                        @foreach ($users as $user)
                            <tr>
                                <td clphpass="table-text"><div>{{ $user->name }}</div></td>
                                @if (auth()->user()->isFollowing($user->id))
                                    <td>
                                        <form action="{{route('unfollow', ['id' => $user->id])}}" method="POST">
                                            {{ csrf_field() }}
                                            {{ method_field('DELETE') }}

                                            <button type="submit" id="delete-follow-{{ $user->id }}" class="btn btn-danger">
                                                <i class="fa fa-btn fa-trash"></i>Unfollow
                                            </button>
                                        </form>
                                    </td>
                                @else
                                    <td>
                                        <form action="{{route('follow', ['id' => $user->id])}}" method="POST">
                                            {{ csrf_field() }}

                                            <button type="submit" id="follow-user-{{ $user->id }}" class="btn btn-success">
                                                <i class="fa fa-btn fa-user"></i>Follow
                                            </button>
                                        </form>
                                    </td>
                                @endif
                            </tr>
                        @endforeach
                        </tbody>
                    </table>
                </div>
            </div>
        </div>
    </div>
@endsection

अब आप /usersउपयोगकर्ताओं की सूची देखने के लिए पेज पर जा सकते हैं।

फॉलो और अनफॉलो करें


में UsersControllerलापता तरीकों followऔर unfollowआइए, उन्हें इस भाग को पूरा करने के लिए कार्यान्वित करें।

//...
class UsersController extends Controller
{
    //...

    public function follow(User $user)
    {
        $follower = auth()->user();
        if ($follower->id == $user->id) {
            return back()->withError("You can't follow yourself");
        }
        if(!$follower->isFollowing($user->id)) {
            $follower->follow($user->id);

            //  
            $user->notify(new UserFollowed($follower));

            return back()->withSuccess("You are now friends with {$user->name}");
        }
        return back()->withError("You are already following {$user->name}");
    }

    public function unfollow(User $user)
    {
        $follower = auth()->user();
        if($follower->isFollowing($user->id)) {
            $follower->unfollow($user->id);
            return back()->withSuccess("You are no longer friends with {$user->name}");
        }
        return back()->withError("You are not following {$user->name}");
    }
}

हम इस कार्यक्षमता के साथ किया जाता है। अब हम उपयोगकर्ताओं की सदस्यता ले सकते हैं और पृष्ठ पर उनसे सदस्यता समाप्त कर सकते हैं /users

सूचनाएं


लारवेल कई चैनलों पर सूचनाएं भेजने के लिए एक एपीआई प्रदान करता है। अधिसूचना वर्ग का उपयोग करके ईमेल, एसएमएस, वेब सूचनाएं और अन्य किसी भी प्रकार के नोटिफिकेशन भेजे जा सकते हैं

हमारे पास दो प्रकार की सूचनाएं होंगी:

  • सदस्यता सूचना: उपयोगकर्ता को तब भेजी जाती है जब कोई अन्य उपयोगकर्ता उसकी सदस्यता लेता है
  • पोस्ट अधिसूचना: एक नया पोस्ट प्रकाशित होने पर इस उपयोगकर्ता के ग्राहकों को भेजा जाता है।

सदस्यता अधिसूचना


कारीगर कमांड का उपयोग करके, हम सूचनाओं के लिए एक माइग्रेशन उत्पन्न कर सकते हैं:

php artisan notifications:table

चलो प्रवास करते हैं और इस तालिका को बनाते हैं।

php artisan migrate

हम सदस्यता सूचनाओं के साथ शुरू करेंगे। एक अधिसूचना वर्ग बनाने के लिए इस कमांड को चलाते हैं:

php artisan make:notification UserFollowed

फिर हम अधिसूचना वर्ग फ़ाइल को संशोधित करते हैं जिसे हमने अभी बनाया है:

class UserFollowed extends Notification implements ShouldQueue
{
    use Queueable;

    protected $follower;

    public function __construct(User $follower)
    {
        $this->follower = $follower;
    }

    public function via($notifiable)
    {
        return ['database'];
    }

    public function toDatabase($notifiable)
    {
        return [
            'follower_id' => $this->follower->id,
            'follower_name' => $this->follower->name,
        ];
    }
}

कोड की इन कुछ पंक्तियों के साथ, हम पहले से ही बहुत कुछ हासिल कर सकते हैं। सबसे पहले, हमें आवश्यकता है कि $followerइस अधिसूचना के उत्पन्न होने पर उदाहरण को लागू किया जाए।

विधि का उपयोग करते हुए via, हम लारवेल को चैनल के माध्यम से यह सूचना भेजने के लिए कहते हैं database। जब लारवेल इसका सामना करता है, तो यह अधिसूचना तालिका में एक नई प्रविष्टि बनाता है।

user_idऔर typeसूचनाएं स्वचालित रूप से सेट की जाती हैं, साथ ही हम अतिरिक्त डेटा के साथ अधिसूचना का विस्तार कर सकते हैं। बस यही बात है toDatabase। लौटाया गया सरणी dataसूचना फ़ील्ड में जोड़ा जाएगा

और अंत में, कार्यान्वयन के लिए धन्यवादShouldQueue, लारवेल स्वचालित रूप से इस अधिसूचना को एक कतार में रखेगा जो पृष्ठभूमि में चलेगा, जो प्रतिक्रिया को गति देगा। इसका अर्थ यह है कि जब हम बाद में पुशर का उपयोग करते हैं तो हम HTTP कॉल जोड़ देंगे।

आइए एक उपयोगकर्ता सदस्यता अधिसूचना को लागू करें।

// ...
use App\Notifications\UserFollowed;
class UsersController extends Controller
{
    // ...
    public function follow(User $user)
    {
        $follower = auth()->user();
        if ( ! $follower->isFollowing($user->id)) {
            $follower->follow($user->id);

            //  ,   
            $user->notify(new UserFollowed($follower));

            return back()->withSuccess("You are now friends with {$user->name}");
        }

        return back()->withSuccess("You are already following {$user->name}");
    }

    //...
}

हम उपयोगकर्ता मॉडल के लिए सूचित विधि को कॉल कर सकते हैं क्योंकि यह पहले से ही Notifiable विशेषता का उपयोग करता है।

कोई भी मॉडल जिसे आप सूचित करना चाहते हैं, उसे सूचना पद्धति तक पहुंच प्राप्त करने के लिए इसका उपयोग करना चाहिए।

हम अधिसूचना को पढ़ते हैं क्योंकि

अधिसूचना में कुछ जानकारी और संसाधन का लिंक होगा। उदाहरण के लिए: जब उपयोगकर्ता को एक नए संदेश के बारे में एक सूचना मिलती है, तो अधिसूचना में सूचनात्मक पाठ होना चाहिए, उपयोगकर्ता को उस संदेश पर पुनर्निर्देशित करें जब दबाया और पढ़ा जाना चाहिए।

हम एक परत बनाने जा रहे हैं जो यह जांच करेगी कि क्या अनुरोध में कोई घटना है ?read=notification_idऔर इसे पढ़ने के रूप में चिह्नित किया गया है।

आइए इस परत को निम्न कमांड से बनाते हैं:

php artisan make:middleware MarkNotificationAsRead

तो फिर इस कोड को handleइंटरलेयर विधि में डालते हैं :

class MarkNotificationAsRead
{
    public function handle($request, Closure $next)
    {
        if($request->has('read')) {
            $notification = $request->user()->notifications()->where('id', $request->read)->first();
            if($notification) {
                $notification->markAsRead();
            }
        }
        return $next($request);
    }
}

हमारी परत को प्रत्येक अनुरोध के लिए निष्पादित करने के लिए, हम इसे जोड़ देंगे $middlewareGroups

//...
class Kernel extends HttpKernel
{
    //...
    protected $middlewareGroups = [
        'web' => [
            //...
            \App\Http\Middleware\MarkNotificationAsRead::class,
        ],
        // ...
    ];
    //...
}

उसके बाद, आइए सूचनाओं को प्रदर्शित करें।

सूचनाएँ प्रदर्शित करें


हमें AJAX का उपयोग करके अधिसूचना सूची दिखाने की आवश्यकता है, और फिर इसे पुशर का उपयोग करके वास्तविक समय में अपडेट करें। सबसे पहले, notificationsनियंत्रक के लिए एक विधि जोड़ें :

// ...
class UsersController extends Controller
{
    // ...
    public function notifications()
    {
        return auth()->user()->unreadNotifications()->limit(5)->get()->toArray();
    }
}

यह कोड अंतिम 5 अपठित सूचनाएँ लौटाएगा। हमें इसे सुलभ बनाने के लिए एक मार्ग जोड़ने की जरूरत है।

//...
Route::group([ 'middleware' => 'auth' ], function () {
    // ...
    Route::get('/notifications', 'UsersController@notifications');
});

अब हेडर में नोटिफिकेशन के लिए एक ड्रॉप-डाउन सूची जोड़ें।

<head>
    <!-- // ... // -->
    <!-- Scripts -->
    <script>
        window.Laravel = <?php echo json_encode([
            'csrfToken' => csrf_token(),
        ]); ?>
    </script>
    <!--   id     JavaScript -->
    @if(!auth()->guest())
        <script>
            window.Laravel.userId = <?php echo auth()->user()->id; ?>
        </script>
    @endif
</head>
<body>
    <!-- // ... // -->
    @if (Auth::guest())
        <li><a href="{{ url('/login') }}">Login</a></li>
        <li><a href="{{ url('/register') }}">Register</a></li>
    @else
        <!-- // add this dropdown // -->
        <li class="dropdown">
            <a class="dropdown-toggle" id="notifications" data-toggle="dropdown" aria-haspopup="true" aria-expanded="true">
                <span class="glyphicon glyphicon-user"></span>
            </a>
            <ul class="dropdown-menu" aria-labelledby="notificationsMenu" id="notificationsMenu">
                <li class="dropdown-header">No notifications</li>
            </ul>
        </li>
<!-- // ... // -->

हमने window.Laravel.userIdवर्तमान उपयोगकर्ता आईडी प्राप्त करने के लिए स्क्रिप्ट में एक वैश्विक चर भी जोड़ा

जावास्क्रिप्ट और SASS


हम जावास्क्रिप्ट और पास को संकलित करने के लिए लारवेल मिक्स का उपयोग करने जा रहे हैं। सबसे पहले, हमें एनपीएम पैकेज स्थापित करने की आवश्यकता है।

npm install

अब इस कोड को इसमें शामिल करते हैं app.js:

window._ = require('lodash');
window.$ = window.jQuery = require('jquery');
require('bootstrap-sass');
var notifications = [];
const NOTIFICATION_TYPES = {
    follow: 'App\\Notifications\\UserFollowed'
};

यह सिर्फ आरंभीकरण है। हम सभी अधिसूचना वस्तुओं को संग्रहीत करने के लिए सूचनाओं का उपयोग करने जा रहे हैं, चाहे वे AJAX या पुशर के माध्यम से पुनर्प्राप्त किए जाएं।

जैसा कि आप शायद पहले ही अनुमान लगा चुके हैं, NOTIFICATION_TYPESइसमें अधिसूचना प्रकार शामिल हैं।

अब AJAX के माध्यम से आइए ("GET") सूचनाएं प्राप्त करें।

//...
$(document).ready(function() {
    // ,      
    if(Laravel.userId) {
        $.get('/notifications', function (data) {
            addNotifications(data, "#notifications");
        });
    }
});
function addNotifications(newNotifications, target) {
    notifications = _.concat(notifications, newNotifications);
    //    5 
    notifications.slice(0, 5);
    showNotifications(notifications, target);
}

इस कोड के लिए धन्यवाद, हम अपने एपीआई से नवीनतम सूचनाएं प्राप्त करते हैं और उन्हें ड्रॉप-डाउन सूची में डालते हैं।

अंदर, addNotificationsहम मौजूदा सूचनाओं को लोडश का उपयोग करके नए के साथ जोड़ते हैं , और केवल अंतिम 5 लेते हैं, जो दिखाया जाएगा।

हमें काम खत्म करने के लिए कुछ और कार्यों की आवश्यकता है।

//...
function showNotifications(notifications, target) {
    if(notifications.length) {
        var htmlElements = notifications.map(function (notification) {
            return makeNotification(notification);
        });
        $(target + 'Menu').html(htmlElements.join(''));
        $(target).addClass('has-notifications')
    } else {
        $(target + 'Menu').html('<li class="dropdown-header">No notifications</li>');
        $(target).removeClass('has-notifications');
    }
}

यह फ़ंक्शन सभी सूचनाओं की एक पंक्ति बनाता है और इसे ड्रॉप-डाउन सूची में रखता है।
यदि कोई सूचना प्राप्त नहीं हुई है, तो बस "कोई सूचना नहीं" प्रदर्शित की जाती है।

यह ड्रॉप-डाउन बटन में एक वर्ग भी जोड़ता है, जो सूचनाओं के होने पर बस रंग बदलता है। गितुब नोटिफिकेशन जैसा थोड़ा सा।

अंत में, अधिसूचना तार बनाने के लिए कुछ सहायक कार्य करता है।

//...
//   
function makeNotification(notification) {
    var to = routeNotification(notification);
    var notificationText = makeNotificationText(notification);
    return '<li><a href="' + to + '">' + notificationText + '</a></li>';
}
//        
function routeNotification(notification) {
    var to = '?read=' + notification.id;
    if(notification.type === NOTIFICATION_TYPES.follow) {
        to = 'users' + to;
    }
    return '/' + to;
}
//        
function makeNotificationText(notification) {
    var text = '';
    if(notification.type === NOTIFICATION_TYPES.follow) {
        const name = notification.data.follower_name;
        text += '<strong>' + name + '</strong> followed you';
    }
    return text;
}

अब हम इसे अपनी फाइल में जोड़ते हैं app.scss:

//... 
#notifications.has-notifications {
  color: #bf5329
}

आइए संपत्तियों का संकलन करें:

npm run dev

अब यदि आप किसी उपयोगकर्ता की सदस्यता लेने का प्रयास करते हैं, तो वह एक सूचना प्राप्त करेगा। जब वह उस पर क्लिक करता है, तो उसे पुनर्निर्देशित किया जाएगा /users, और अधिसूचना स्वयं गायब हो जाती है।

नई पोस्ट अधिसूचना


जब कोई उपयोगकर्ता एक नई पोस्ट प्रकाशित करता है तो हम ग्राहकों को सूचित करने जा रहे हैं।

एक अधिसूचना वर्ग बनाकर शुरू करते हैं।

php artisan make:notification NewPost

आइए उत्पन्न वर्ग को निम्नानुसार संशोधित करें:

// ..
use App\Post;
use App\User;
class NewArticle extends Notification implements ShouldQueue
{
    // ..
    protected $following;
    protected $post;
    public function __construct(User $following, Post $post)
    {
        $this->following = $following;
        $this->post = $post;
    }
    public function via($notifiable)
    {
        return ['database'];
    }
    public function toDatabase($notifiable)
    {
        return [
            'following_id' => $this->following->id,
            'following_name' => $this->following->name,
            'post_id' => $this->post->id,
        ];
    }
}

आगे हमें एक अधिसूचना भेजने की आवश्यकता है। इसे करने बहुत सारे तरीके हैं।

मुझे एलोकेंट वॉचर्स का इस्तेमाल करना पसंद है।

आइए पोस्ट के लिए एक पर्यवेक्षक बनाएं और इसकी घटनाओं को सुनें। हम एक नया वर्ग बनाएंगे:app/Observers/PostObserver.php

namespace App\Observers;
use App\Notifications\NewPost;
use App\Post;
class PostObserver
{
    public function created(Post $post)
    {
        $user = $post->user;
        foreach ($user->followers as $follower) {
            $follower->notify(new NewPost($user, $post));
        }
    }
}

फिर पर्यवेक्षक को इसमें पंजीकृत करें AppServiceProvider:

//...
use App\Observers\PostObserver;
use App\Post;
class AppServiceProvider extends ServiceProvider
{
    //...
    public function boot()
    {
        Post::observe(PostObserver::class);
    }
    //...
}

अब हमें केवल जेएस में प्रदर्शन के लिए संदेश को प्रारूपित करने की आवश्यकता है:

// ...
const NOTIFICATION_TYPES = {
    follow: 'App\\Notifications\\UserFollowed',
    newPost: 'App\\Notifications\\NewPost'
};
//...
function routeNotification(notification) {
    var to = `?read=${notification.id}`;
    if(notification.type === NOTIFICATION_TYPES.follow) {
        to = 'users' + to;
    } else if(notification.type === NOTIFICATION_TYPES.newPost) {
        const postId = notification.data.post_id;
        to = `posts/${postId}` + to;
    }
    return '/' + to;
}
function makeNotificationText(notification) {
    var text = '';
    if(notification.type === NOTIFICATION_TYPES.follow) {
        const name = notification.data.follower_name;
        text += `<strong>${name}</strong> followed you`;
    } else if(notification.type === NOTIFICATION_TYPES.newPost) {
        const name = notification.data.following_name;
        text += `<strong>${name}</strong> published a post`;
    }
    return text;
}

और वोइला! उपयोगकर्ताओं को सदस्यता और नए पदों की सूचना दी जाती है! इसे स्वयं आज़माएं!

पुशर के साथ वास्तविक समय में बाहर निकलें


यह वेब सॉकेट के माध्यम से वास्तविक समय की सूचनाएं प्राप्त करने के लिए पुशर का उपयोग करने का समय है। Pusher.com

पर मुफ्त पुशर खाते के लिए पंजीकरण करें और एक नया ऐप बनाएं।

...
BROADCAST_DRIVER=pusher
PUSHER_KEY=
PUSHER_SECRET=
PUSHER_APP_ID=

कॉन्फ़िगरेशन फ़ाइल में अपने खाते के लिए पैरामीटर सेट करें broadcasting:

//...
    'connections' => [
            'pusher' => [
                //...
                'options' => [
                    'cluster' => 'eu',
                    'encrypted' => true
                ],
            ],
    //...

फिर हम App\Providers\BroadcastServiceProviderएरे में रजिस्टर करेंगे providers

// ...
'providers' => [
    // ...
    App\Providers\BroadcastServiceProvider
    //...
],
//...

अब हमें Pusher से PHP SDK और Laravel Echo स्थापित करने की आवश्यकता है:

composer require pusher/pusher-php-server
npm install --save laravel-echo pusher-js

हमें प्रसारण के लिए अधिसूचना डेटा सेट करने की आवश्यकता है। आइए अधिसूचना को संशोधित करें UserFollowed:

//...
class UserFollowed extends Notification implements ShouldQueue
{
    // ..
    public function via($notifiable)
    {
        return ['database', 'broadcast'];
    }
    //...
    public function toArray($notifiable)
    {
        return [
            'id' => $this->id,
            'read_at' => null,
            'data' => [
                'follower_id' => $this->follower->id,
                'follower_name' => $this->follower->name,
            ],
        ];
    }
}

और NewPost:

//...
class NewPost extends Notification implements ShouldQueue
{
    //...
    public function via($notifiable)
    {
        return ['database', 'broadcast'];
    }
    //...
    public function toArray($notifiable)
    {
        return [
            'id' => $this->id,
            'read_at' => null,
            'data' => [
                'following_id' => $this->following->id,
                'following_name' => $this->following->name,
                'post_id' => $this->post->id,
            ],
        ];
    }
}

आखिरी चीज जो हमें करने की जरूरत है वह है हमारे जेएस को अपडेट करना। app.jsनिम्न कोड खोलें और जोड़ें

// ...
window.Pusher = require('pusher-js');
import Echo from "laravel-echo";
window.Echo = new Echo({
    broadcaster: 'pusher',
    key: 'your-pusher-key',
    cluster: 'eu',
    encrypted: true
});
var notifications = [];
//...
$(document).ready(function() {
    if(Laravel.userId) {
        //...
        window.Echo.private(`App.User.${Laravel.userId}`)
            .notification((notification) => {
                addNotifications([notification], '#notifications');
            });
    }
});

इतना ही। वास्तविक समय में सूचनाएं जोड़ी जाती हैं। अब आप एप्लिकेशन के साथ खेल सकते हैं और देख सकते हैं कि सूचनाएं कैसे अपडेट की जाती हैं।

निष्कर्ष


पुशर में एक बहुत उपयोगकर्ता के अनुकूल एपीआई है जो वास्तविक समय की घटना के कार्यान्वयन को अविश्वसनीय रूप से सरल बनाता है। लारवेल नोटिफिकेशन के संयोजन में, हम एक जगह से कई चैनलों (ईमेल, एसएमएस, स्लैक आदि) के माध्यम से सूचनाएं भेज सकते हैं। इस गाइड में, हमने एक साधारण ब्लॉग में उपयोगकर्ता गतिविधि को ट्रैक करने के लिए कार्यक्षमता को जोड़ा और कुछ चिकनी वास्तविक समय की कार्यक्षमता प्राप्त करने के लिए उपरोक्त उपकरणों का उपयोग करके इसमें सुधार किया।

पुशर और लारवेल में बहुत अधिक सूचनाएं हैं: अग्रानुक्रम में, सेवाएं आपको वास्तविक समय में ब्राउज़र, मोबाइल फोन और आईओटी उपकरणों पर पब / उप संदेश भेजने की अनुमति देती हैं। ऑनलाइन / ऑफलाइन उपयोगकर्ता का दर्जा प्राप्त करने के लिए भी एक एपीआई है।

कृपया उनके दस्तावेज देखें ( Pusher docs), पुष्कर ट्यूटोरियल , लारवेल डॉक्स ) उनके उपयोग और वास्तविक क्षमता के बारे में अधिक जानने के लिए।

यदि आपके पास कोई टिप्पणी, प्रश्न या सिफारिशें हैं, तो नीचे टिप्पणी में उन्हें साझा करने के लिए स्वतंत्र महसूस करें!



पाठ्यक्रम के बारे में अधिक जानें।



All Articles