Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Notifications;

use Illuminate\Contracts\Queue\ShouldQueue;

use Illuminate\Contracts\Translation\HasLocalePreference;

use Illuminate\Database\Eloquent\Collection as ModelCollection;

use Illuminate\Database\Eloquent\Model;

use Illuminate\Notifications\Events\NotificationSending;

use Illuminate\Notifications\Events\NotificationSent;

use Illuminate\Support\Collection;

use Illuminate\Support\Str;

use Illuminate\Support\Traits\Localizable;

class NotificationSender

{

    use Localizable;

    /**

     * The notification manager instance.

     *

     * @var \Illuminate\Notifications\ChannelManager

     */

    protected $manager;

    /**

     * The Bus dispatcher instance.

     *

     * @var \Illuminate\Contracts\Bus\Dispatcher

     */

    protected $bus;

    /**

     * The event dispatcher.

     *

     * @var \Illuminate\Contracts\Events\Dispatcher

     */

    protected $events;

    /**

     * The locale to be used when sending notifications.

     *

     * @var string|null

     */

    protected $locale;

    /**

     * Create a new notification sender instance.

     *

     * @param  \Illuminate\Notifications\ChannelManager  $manager

     * @param  \Illuminate\Contracts\Bus\Dispatcher  $bus

     * @param  \Illuminate\Contracts\Events\Dispatcher  $events

     * @param  string|null  $locale

     * @return void

     */

    public function __construct($manager, $bus, $events, $locale = null)

    {

        $this->bus = $bus;

        $this->events = $events;

        $this->locale = $locale;

        $this->manager = $manager;

    }

    /**

     * Send the given notification to the given notifiable entities.

     *

     * @param  \Illuminate\Support\Collection|array|mixed  $notifiables

     * @param  mixed  $notification

     * @return void

     */

    public function send($notifiables, $notification)

    {

        $notifiables = $this->formatNotifiables($notifiables);

        if ($notification instanceof ShouldQueue) {

            return $this->queueNotification($notifiables, $notification);

        }

        $this->sendNow($notifiables, $notification);

    }

    /**

     * Send the given notification immediately.

     *

     * @param  \Illuminate\Support\Collection|array|mixed  $notifiables

     * @param  mixed  $notification

     * @param  array|null  $channels

     * @return void

     */

    public function sendNow($notifiables, $notification, array $channels = null)

    {

        $notifiables = $this->formatNotifiables($notifiables);

        $original = clone $notification;

        foreach ($notifiables as $notifiable) {

            if (empty($viaChannels = $channels ?: $notification->via($notifiable))) {

                continue;

            }

            $this->withLocale($this->preferredLocale($notifiable, $notification), function () use ($viaChannels, $notifiable, $original) {

                $notificationId = Str::uuid()->toString();

                foreach ((array) $viaChannels as $channel) {

                    if (! ($notifiable instanceof AnonymousNotifiable && $channel === 'database')) {

                        $this->sendToNotifiable($notifiable, $notificationId, clone $original, $channel);

                    }

                }

            });

        }

    }

    /**

     * Get the notifiable's preferred locale for the notification.

     *

     * @param  mixed  $notifiable

     * @param  mixed  $notification

     * @return string|null

     */

    protected function preferredLocale($notifiable, $notification)

    {

        return $notification->locale ?? $this->locale ?? value(function () use ($notifiable) {

            if ($notifiable instanceof HasLocalePreference) {

                return $notifiable->preferredLocale();

            }

        });

    }

    /**

     * Send the given notification to the given notifiable via a channel.

     *

     * @param  mixed  $notifiable

     * @param  string  $id

     * @param  mixed  $notification

     * @param  string  $channel

     * @return void

     */

    protected function sendToNotifiable($notifiable, $id, $notification, $channel)

    {

        if (! $notification->id) {

            $notification->id = $id;

        }

        if (! $this->shouldSendNotification($notifiable, $notification, $channel)) {

            return;

        }

        $response = $this->manager->driver($channel)->send($notifiable, $notification);

        $this->events->dispatch(

            new NotificationSent($notifiable, $notification, $channel, $response)

        );

    }

    /**

     * Determines if the notification can be sent.

     *

     * @param  mixed  $notifiable

     * @param  mixed  $notification

     * @param  string  $channel

     * @return bool

     */

    protected function shouldSendNotification($notifiable, $notification, $channel)

    {

        if (method_exists($notification, 'shouldSend') &&

            $notification->shouldSend($notifiable, $channel) === false) {

            return false;

        }

        return $this->events->until(

            new NotificationSending($notifiable, $notification, $channel)

        ) !== false;

    }

    /**

     * Queue the given notification instances.

     *

     * @param  mixed  $notifiables

     * @param  \Illuminate\Notifications\Notification  $notification

     * @return void

     */

    protected function queueNotification($notifiables, $notification)

    {

        $notifiables = $this->formatNotifiables($notifiables);

        $original = clone $notification;

        foreach ($notifiables as $notifiable) {

            $notificationId = Str::uuid()->toString();

            foreach ((array) $original->via($notifiable) as $channel) {

                $notification = clone $original;

                if (! $notification->id) {

                    $notification->id = $notificationId;

                }

                if (! is_null($this->locale)) {

                    $notification->locale = $this->locale;

                }

                $connection = $notification->connection;

                if (method_exists($notification, 'viaConnections')) {

                    $connection = $notification->viaConnections()[$channel] ?? null;

                }

                $queue = $notification->queue;

                if (method_exists($notification, 'viaQueues')) {

                    $queue = $notification->viaQueues()[$channel] ?? null;

                }

                $delay = $notification->delay;

                if (method_exists($notification, 'withDelay')) {

                    $delay = $notification->withDelay($notifiable, $channel) ?? null;

                }

                $middleware = $notification->middleware ?? [];

                if (method_exists($notification, 'middleware')) {

                    $middleware = array_merge(

                        $notification->middleware($notifiable, $channel),

                        $middleware

                    );

                }

                $this->bus->dispatch(

                    (new SendQueuedNotifications($notifiable, $notification, [$channel]))

                            ->onConnection($connection)

                            ->onQueue($queue)

                            ->delay(is_array($delay) ? ($delay[$channel] ?? null) : $delay)

                            ->through($middleware)

                );

            }

        }

    }

    /**

     * Format the notifiables into a Collection / array if necessary.

     *

     * @param  mixed  $notifiables

     * @return \Illuminate\Database\Eloquent\Collection|array

     */

    protected function formatNotifiables($notifiables)

    {

        if (! $notifiables instanceof Collection && ! is_array($notifiables)) {

            return $notifiables instanceof Model

                            ? new ModelCollection([$notifiables]) : [$notifiables];

        }

        return $notifiables;

    }

}