php - real - Laravel 5.3-Notificación única para la colección de usuarios(seguidores)

real time notifications laravel

Question

Cuando tengo un único usuario notifiable , se inserta una sola entrada en la tabla de notifications , junto con un mail / sms enviado que funciona perfectamente a través de los canales.

El problema es cuando tengo una colección de user , una lista de usuarios de 1k que me siguen y publico una actualización. Esto es lo que sucede cuando se utiliza el rasgo Notifiable como se sugiere para el caso de varios usuarios:

1. 1k mails / sms enviados (el problema no está aquí)
2. 1k entradas de notificación agregadas a la tabla de notifications la base de datos

Parece que agregar 1k notificaciones a la tabla de notificaciones de la base de datos no es una solución óptima. Dado que los datos de toArray son los mismos, y todo lo demás en la tabla de notifications la base de datos es el mismo para las filas de 1k, con la única diferencia es el notifiable_id del user notifiable_type .

Una solución óptima fuera de la caja sería:

1. Laravel reconocería el hecho de que se trata de una array notifiable_type
2. Guarde una notificación única como user_array o user con user_array 0 (cero solo se usaría para indicar que es un usuario con múltiples notificaciones)

3. Cree / use otra tabla notifications_read usando la notification_id se acaba de crear como foreign_key e inserte filas de 1k, solo de estos campos:

   notification_id read_at

Espero que ya haya una forma de hacerlo ya que estoy en este punto de mi aplicación y me encantaría usar los Notificaciones y canales integrados para esta situación, ya que estoy disparando las notificaciones de emails / sms , lo cual está bien para repetir Creo que 1k veces, pero es la entrada de los mismos datos en la base de datos el problema que debe optimizarse.

¿Alguna idea / idea de cómo proceder en esta situación?

Answer 1

Actualizado 2017-01-14: implementado enfoque más correcto

Ejemplo rápido:

use Illuminate/Support/Facades/Notification;
use App/Notifications/SomethingCoolHappen;

Route::get(''/step1'', function () {
    // example - my followers
    $followers = App/User::all();

    // notify them
    Notification::send($followers, new SomethingCoolHappen([''arg1'' => 1, ''arg2'' => 2]));
});

Route::get(''/step2'', function () {
    // my follower
    $user = App/User::find(10);

    // check unread subnotifications
    foreach ($user->unreadSubnotifications as $subnotification) {
        var_dump($subnotification->notification->data);
        $subnotification->markAsRead();
    }
});

¿Cómo hacer que funcione?

Paso 1 - migración - crear tabla (subnotificaciones)

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

class CreateSubnotificationsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create(''subnotifications'', function (Blueprint $table) {
            // primary key
            $table->increments(''id'')->primary();

            // notifications.id
            $table->uuid(''notification_id'');

            // notifiable_id and notifiable_type
            $table->morphs(''notifiable'');

            // follower - read_at
            $table->timestamp(''read_at'')->nullable();
        });
    }

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

Paso 2 - vamos a crear un modelo para la nueva tabla de subnotificaciones

<?php
// App/Notifications/Subnotification.php
namespace App/Notifications;

use Illuminate/Database/Eloquent/Model;
use Illuminate/Notifications/DatabaseNotification;
use Illuminate/Notifications/DatabaseNotificationCollection;

class Subnotification extends Model
{
    // we don''t use created_at/updated_at
    public $timestamps = false;

    // nothing guarded - mass assigment allowed
    protected $guarded = [];

    // cast read_at as datetime
    protected $casts = [
        ''read_at'' => ''datetime'',
    ];

    // set up relation to the parent notification
    public function notification()
    {
        return $this->belongsTo(DatabaseNotification::class);
    }

    /**
     * Get the notifiable entity that the notification belongs to.
     */
    public function notifiable()
    {
        return $this->morphTo();
    }

    /**
     * Mark the subnotification as read.
     *
     * @return void
     */
    public function markAsRead()
    {
        if (is_null($this->read_at)) {
            $this->forceFill([''read_at'' => $this->freshTimestamp()])->save();
        }
    }
}

Paso 3 - crear un canal de notificación de base de datos personalizado
Actualizado : usando la variable estática $ map para mantener la primera identificación de notificación e insertar las siguientes notificaciones (con los mismos datos) sin crear un registro en la tabla de notifications

<?php
// App/Channels/SubnotificationsChannel.php
namespace App/Channels;

use Illuminate/Notifications/DatabaseNotification;
use Illuminate/Notifications/Notification;

class SubnotificationsChannel
{
    /**
     * Send the given notification.
     *
     * @param  mixed                                  $notifiable
     * @param  /Illuminate/Notifications/Notification $notification
     *
     * @return void
     */
    public function send($notifiable, Notification $notification)
    {
        static $map = [];

        $notificationId = $notification->id;

        // get notification data
        $data = $this->getData($notifiable, $notification);

        // calculate hash
        $hash = md5(json_encode($data));

        // if hash is not in map - create parent notification record
        if (!isset($map[$hash])) {
            // create original notification record with empty notifiable_id
            DatabaseNotification::create([
                ''id''              => $notificationId,
                ''type''            => get_class($notification),
                ''notifiable_id''   => 0,
                ''notifiable_type'' => get_class($notifiable),
                ''data''            => $data,
                ''read_at''         => null,
            ]);

            $map[$hash] = $notificationId;
        } else {
            // otherwise use another/first notification id
            $notificationId = $map[$hash];
        }

        // create subnotification
        $notifiable->subnotifications()->create([
            ''notification_id'' => $notificationId,
            ''read_at''         => null
        ]);
    }

    /**
     * Prepares data
     *
     * @param mixed                                  $notifiable
     * @param /Illuminate/Notifications/Notification $notification
     *
     * @return mixed
     */
    public function getData($notifiable, Notification $notification)
    {
        return $notification->toArray($notifiable);
    }
}

Paso 4 - crear una notificación
Actualizado : ahora la notificación es compatible con todos los canales, no solo con subnotificaciones

<?php
// App/Notifications/SomethingCoolHappen.php
namespace App/Notifications;

use App/Channels/SubnotificationsChannel;
use Illuminate/Bus/Queueable;
use Illuminate/Notifications/Notification;
use Illuminate/Contracts/Queue/ShouldQueue;
use Illuminate/Notifications/Messages/MailMessage;

class SomethingCoolHappen extends Notification
{
    use Queueable;

    protected $data;

    /**
     * Create a new notification instance.
     *
     * @return void
     */
    public function __construct($data)
    {
        $this->data = $data;
    }

    /**
     * Get the notification''s delivery channels.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function via($notifiable)
    {
        /**
         * THIS IS A GOOD PLACE FOR DETERMINING NECESSARY CHANNELS
         */
        $via = [];
        $via[] = SubnotificationsChannel::class;
        //$via[] = ''mail'';
        return $via;
    }

    /**
     * Get the mail representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return /Illuminate/Notifications/Messages/MailMessage
     */
    public function toMail($notifiable)
    {
        return (new MailMessage)
                    ->line(''The introduction to the notification.'')
                    ->action(''Notification Action'', ''https://laravel.com'')
                    ->line(''Thank you for using our application!'');
    }

    /**
     * Get the array representation of the notification.
     *
     * @param  mixed  $notifiable
     * @return array
     */
    public function toArray($notifiable)
    {
        return $this->data;
    }
}

Paso 5 - rasgo de ayudante para "seguidores"

<?php
// App/Notifications/HasSubnotifications.php
namespace App/Notifications;

trait HasSubnotifications
{
    /**
     * Get the entity''s notifications.
     */
    public function Subnotifications()
    {
        return $this->morphMany(Subnotification::class, ''notifiable'')
            ->orderBy(''id'', ''desc'');
    }

    /**
     * Get the entity''s read notifications.
     */
    public function readSubnotifications()
    {
        return $this->Subnotifications()
            ->whereNotNull(''read_at'');
    }

    /**
     * Get the entity''s unread notifications.
     */
    public function unreadSubnotifications()
    {
        return $this->Subnotifications()
            ->whereNull(''read_at'');
    }
}

Paso 6 - actualiza tu modelo de Usuarios
Actualizado : no requiere método de seguidores

namespace App;

use App/Notifications/HasSubnotifications;
use Illuminate/Notifications/Notifiable;
use Illuminate/Foundation/Auth/User as Authenticatable;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * Adding helpers to followers:
     *
     * $user->subnotifications - all subnotifications
     * $user->unreadSubnotifications - all unread subnotifications
     * $user->readSubnotifications - all read subnotifications
     */
    use HasSubnotifications;

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

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        ''password'', ''remember_token'',
    ];
}

Answer 2

Sí, tienes razón, supongo que con el rasgo Notifiable predeterminado, puedes crear un canal personalizado .

Puede consultar la clase Illuminate/Notifications/Channels/DatabaseChannel para la creación por defecto y adoptarla en una tabla dinámica.

Espero que esto ayude a crear un nuevo canal con una tabla dinámica. Además, implemente un rasgo HasDatabasePivotNotifications (o nombre similar) a su propio rasgo Notifiable .