How to Save Notifications in the Database in Laravel

 How to Save Notifications in the Database in Laravel

Laravel provides a built-in way to store notifications in the database using the database channel. Here’s how you can set it up.

1. Create the Notifications Table

Laravel comes with a built-in migration for notifications. If you haven’t migrated it yet, run:


php artisan notifications:table
php artisan migrate

This will create a notifications table in your database with fields like:

  • id (unique identifier)
  • type (notification class)
  • notifiable_id & notifiable_type (user or model that received the notification)
  • data (JSON field storing notification details)
  • read_at (timestamp for when the notification is read)

2. Update Your Notification Class

Modify your CommentAddedNotification to use the database channel and store data.

Example: app/Notifications/CommentAddedNotification.php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;

class CommentAddedNotification extends Notification implements ShouldQueue
{
    use Queueable;

    protected $task;
    protected $comment;

    public function __construct($task, $comment)
    {
        $this->task = $task;
        $this->comment = $comment;
    }

    // Define which channels the notification should be sent through
    public function via($notifiable): array
    {
        return ['database']; // Store the notification in the database
    }

    // Define the data that should be stored in the database
    public function toArray($notifiable): array
    {
        return [
            'task_id' => $this->task->id,
            'task_title' => $this->task->title,
            'comment' => $this->comment,
            'commented_by' => auth()->user()->name,
            'created_at' => now(),
        ];
    }
}

3. Send the Notification

You can send the notification to a user like this:


$user->notify(new CommentAddedNotification($task, $comment));

Alternatively, you can use the Notification facade:

use App\Notifications\CommentAddedNotification;
use Illuminate\Support\Facades\Notification;

Notification::send($user, new CommentAddedNotification($task, $comment));

4. Retrieve Stored Notifications

In your controller or view, fetch the user’s notifications:

php
$notifications = auth()->user()->notifications; // Get all notifications

If you only want unread notifications:


$unreadNotifications = auth()->user()->unreadNotifications;

5. Mark Notifications as Read

Once a user views the notification, mark it as read:


auth()->user()->unreadNotifications->markAsRead();

To mark a specific notification as read:


$notification = auth()->user()->notifications()->find($notificationId);
if ($notification) {
    $notification->markAsRead();
}

6. Display Notifications in Blade

Example: Showing Notifications in a Dashboard

In resources/views/notifications.blade.php:


<ul>
    @foreach(auth()->user()->notifications as $notification)
        <li>
            <strong>{{ $notification->data['task_title'] }}</strong> - 
            {{ $notification->data['comment'] }} (by {{ $notification->data['commented_by'] }})
            <small>{{ $notification->created_at->diffForHumans() }}</small>
            @if(!$notification->read_at)
                <form method="POST" action="{{ route('notifications.read', $notification->id) }}">
                    @csrf
                    <button type="submit">Mark as Read</button>
                </form>
            @endif
        </li>
    @endforeach
</ul>

7. Create a Route and Controller Method

In routes/web.php:


use App\Http\Controllers\NotificationController;

Route::post('/notifications/read/{id}', [NotificationController::class, 'markAsRead'])->name('notifications.read');

In app/Http/Controllers/NotificationController.php:


namespace App\Http\Controllers;

use Illuminate\Http\Request;

class NotificationController extends Controller
{
    public function markAsRead($id)
    {
        $notification = auth()->user()->notifications()->find($id);
        if ($notification) {
            $notification->markAsRead();
        }
        return back();
    }
}

Summary

  1. Migrate the notifications table (php artisan notifications:table && php artisan migrate).
  2. Update the notification class to use the database channel and store data.
  3. Send notifications to users ($user->notify(new CommentAddedNotification($task, $comment))).
  4. Retrieve notifications in a controller (auth()->user()->notifications).
  5. Mark notifications as read using markAsRead().

Now, notifications will be stored in the database and can be displayed in the UI! 🚀 Let me know if you need further customization.

Comments

Post a Comment

What is your thought about this?

Popular posts from this blog

Top Laravel Security Best Practices: How to Secure Your Web Application 🚀

Image
Top Laravel Security Best Practices: How to Secure Your Web Application 🚀 Laravel is one of the most popular PHP frameworks for web application development, known for its elegant syntax and robust features. However, security is a critical concern when building applications that handle sensitive data. This guide outlines essential security best practices to protect your Laravel application from vulnerabilities such as SQL injection, XSS, CSRF, and other threats. 1. Authentication & Authorization Laravel provides built-in authentication systems that make user authentication easy and secure. Use Laravel Breeze or Jetstream for authentication instead of building it from scratch. Implement Role-Based Access Control (RBAC) to manage permissions effectively. Enforce Multi-Factor Authentication (MFA) where necessary to add an extra layer of security. 2. Prevent SQL Injection SQL injection is a serious threat, but Laravel’s Eloquent ORM and Query Builder help prevent it...
Read more

useCallback hook in React

`useCallback` is a useful hook for optimizing performance in React applications by preventing unnecessary re-creations of functions. However, you should use it wisely, as it can add complexity and may not always offer a performance improvement in every case. ### 1. **What does `useCallback` do?** `useCallback` returns a memoized version of the callback function that only changes if one of the dependencies has changed. It’s primarily used when passing a function as a prop to child components or using it in an effect (like `useEffect`), where unnecessary re-creations of the function can lead to performance problems. ### 2. **Syntax:** ```javascript const memoizedCallback = useCallback(() => {   // Your callback code }, [dependencies]); ``` - The first argument is the function you want to memoize. - The second argument is an array of dependencies (like `useEffect`). The function will only be re-created if any of these dependencies change. ### 3. **When to use `useCallback`?** You s...
Read more

Passing array from child to parent component

 To pass the assigned_users array from a child component to its parent component, you need to follow these steps: Create a callback function in the parent component : This function will be responsible for receiving the assigned_users array. Pass the callback function to the child component as a prop : The child component can then call this function when it wants to send the assigned_users array to the parent. Call the callback function from the child component : Inside the child component, when you want to send the data to the parent (e.g., after updating assigned_users ), you call the callback function with the updated array. Parent Component jsx Copy code import React , { useState } from 'react' ; import ChildComponent from './ChildComponent' ; const ParentComponent = ( ) => { const [assignedUsers, setAssignedUsers] = useState ([]); // Callback function to update the parent state const handleAssignedUsersChange = ( users ) => { setAssig...
Read more