Send the notifications.

@param  \Illuminate\Notifications\ChannelManager  $manager
@return void
335415
public function handle(ChannelManager $manager)
    {
        $manager->sendNow($this->notifiables, $this->notification, $this->channels);
    }
1046447
public function addToManager(Manager $manager)
    {
        $this->extend('onBeforeAddToManager', $manager);
        $scaffold = $this->scaffold($manager);
        if (!$manager->hasType($this->getTypeName())) {
            $manager->addType($scaffold, $this->getTypeName());
        }

        foreach ($this->operations as $op) {
            $op->addToManager($manager);
        }

        foreach ($this->nestedQueries as $scaffold) {
            $scaffold->addToManager($manager);
        }

        $this->extend('onAfterAddToManager', $manager);
    }
58269
async def _send_manager_command(self, *args, **kwargs):
        """"""
        resp = await send_manager_command(*args, **kwargs)

        if resp is False:
            await self.terminate()
162713
public void sendAdminNotification(NotificationType type,
                                      String subject,
                                      String message) {
        for (Notifier notifier : notifiers) {
            if (notifier.getNotificationType().equals(type)) {
                notifier.notifyAdmins(subject, message);
            }
        }
    }
1277617
public function notify()
    {
        \BFW\Application::getInstance()
            ->getMonolog()
            ->getLogger()
            ->debug(
                'Subject notify event',
                ['action' => $this->action]
            );
        
        foreach ($this->observers as $observer) {
            $observer->update($this);
        }
    }
652584
public function publish($channel, $message)
    {
        $topic = $this->getTopicForChannel($channel);
        $payload = Utils::serializeMessage($message);

        if ($this->backgroundBatching) {
            $topic->batchPublisher()->publish(['data' => $payload]);
        } else {
            $topic->publish(['data' => $payload]);
        }
    }
166160
protected function attachSelfToEventManager()
    {
        if (!$this->listener_attached) {
            if ($this->event_manager instanceof ListenerAwareInterface &&
                $this instanceof ListenerInterface
            ) {
                $this->event_manager->attachListener($this);
            }
            $this->listener_attached = true;
        }
    }
694180
public function notifyNow($instance, array $channels = null)
    {
        app(Dispatcher::class)->sendNow($this, $instance, $channels);
    }
1254421
public function sendNotification($channels, Message $message, $options=array())
    {
        $status = array();
        foreach ($channels as $channel) {
            $notifier = $this->_getNotifier($channel);
            if (empty($notifier) === false) {
                $status[$channel] = $notifier->notify($message, $options);
            }

            return $status;
        }

    }
99759
public function send($notifiables, $notifications)
    {
        if (!is_array($notifiables)) {
            $notifiables = [$notifiables];
        }
        if (!is_array($notifications)) {
            $notifications = [$notifications];
        }
        foreach ($notifiables as $notifiable) {
            $channels = array_intersect($notifiable->viaChannels(), array_keys($this->getChannels(true)));
            foreach ($notifications as $notification) {
                if (!$notifiable->shouldReceiveNotification($notification)) {
                    continue;
                }
                $notification->id = StringHelper::ObjectId();
                $channels = array_intersect($channels, $notification->broadcastOn());
                foreach ($channels as $channel) {
                    $this->get($channel)->send($notifiable, $notification);
                }
            }
        }
    }
664055
protected function sendEmail($message): void
    {
        $snooze = \is_numeric($this->emailSnooze)
            ? $this->emailSnooze
            : \strtotime($this->emailSnooze) - \time();

        if ($this->email && $this->mailer
            && @\filemtime($this->directory . '/email-sent') + $snooze < \time() // @ file may not exist
            && @\file_put_contents($this->directory . '/email-sent', 'sent') // @ file may not be writable
        ) {
            ($this->mailer)($message, \implode(', ', (array) $this->email));
        }
    }
480097
public function sendAll($msg) : void
    {
        foreach ($this->subscriptionTable->findActive() as $row)
        {
            $this->sendNotification($row, $msg, false);
        }

        if ($flush)
        {
            $this->flush();
        }
    }
185452
private function SendMessage($message)
    {
        $this->signal_data->message = $message;
        
        $this->Send(
            \Peg\Lib\Signals\Type\Definitions::IMPORT_MESSAGE,
            $this->signal_data
        );
    }
773020
public static function notice($message, array $context = [], string $channel = self::DEFAULT_CHANNEL): void
    {
        self::log(LogLevel::NOTICE, $message, $context, $channel);
    }
541063
public function fire(PackageManagerInterface $manager)
    {
        $packages = [];

        $i = 0;

        /** @var PackageInterface[] $packagesList */
        $packagesList = $manager->all();

        foreach ($packagesList as $name => $package) {
            /** @var AssetElementInterface[] $files */
            $files = $package->all();

            foreach ($files as $file) {
                if (isset($packages[$name])) {
                    $packages[$i]['id'] = '';
                    $packages[$i]['files'] = $file->getSrc();
                    $packages[$i]['deps'] = $file->getDependency();

                    $i++;
                } else {
                    $packages[$name]['id'] = $name;
                    $packages[$name]['files'] = $file->getSrc();
                    $packages[$name]['deps'] = $file->getDependency();
                }
            }

            $packages[$i] = new TableSeparator();
            $i++;
        }

        foreach ($packages as $i => $data) {
            foreach ($data as $key => $rows) {
                if (is_array($rows)) {
                    $packages[$i][$key] = implode(', ', $rows);
                }
            }
        }

        $this->table($this->headers, $packages);
    }
42333
public function send($notifiable, Notification $notification)
    {
        if (!$to = $notifiable->routeNotificationFor('SMS')) {
            return;
        }

        $message = $notification->toSMS($notifiable);
        if (is_string($message)) {
            $message = new SMSMessage($message);
        }

        $this->SMSManager
            ->channel($message->channel)
            ->send($to, $message->content);
    }
819963
public function sendTo(Recipient $recipient, MessageInterface $message)
    {
        $driver = "\\Eyewitness\\Eye\\Notifications\\Drivers\\".ucfirst(strtolower($recipient->type));

        if (class_exists($driver)) {
            $channel = app($driver);
            $channel->fire($recipient, $message);
        } else {
            app(Eye::class)->logger()->debug('Notification Driver does not exist', $driver);
        }
    }