Send message through SmsCenter.pl gateway
@param SmsMessageModel $message
@return bool
432271
public function send(MessageInterface $message, $skipErrors = true) {

        $mobitex = $this->getClient();
        
        foreach ($message->getRecipient() as $recipient) {
            try {
                $mobitex->sendMessage($recipient, $message->getText());
            }
            catch (Exception $e) {
                $this->addError(new SendingError($recipient, $e->getCode(), $e->getMessage()));
                if (!$skipErrors) {
                    throw new \RuntimeException($e->getMessage(), $e->getCode());
                }
            }
        }
        return $this->getErrors()->count() === 0;
    }
713814
public function send(MessageInterface $message, &$failures = null)
    {
        if ($this->disableDelivery) {
            return true;
        }

        $data = [];
        $ld = $this->config->get('Decorators.Wrapper.0', '');
        $rd = $this->config->get('Decorators.Wrapper.1', '');
        foreach ($this->decorators as $email => $vars) {
            foreach ($vars as $name => $content) {
                $data[$ld . $name . $rd][] = $content;
            }
        }

        $msg = $message();
        /* @var $msg Email */
        $msg->setSubstitutions($data);

        $res = $this->mailer->send($message());

        if ($res->message == 'success') {
            return true;
        }

        return false;
    }
700715
public function send($mobileNumber, $message, $messageId = null)
    {
        return $this->app['chikka.sender']->send($mobileNumber, $message, $messageId);
    }
1170501
public function send(OutgoingMessage $message)
    {
        $from = $message->getFrom();
        $composeMessage = $message->composeMessage();

        $numbers = $message->getToWithCarriers();

        if (count($numbers) > 1) {
            $endpoint = '/send-sms-multiple';
            $data = [
                'sendSmsMultiRequest' => ['sendSmsRequestList' => []],
            ];

            foreach ($numbers as $key => $item) {
                array_push($data['sendSmsMultiRequest']['sendSmsRequestList'],
                    $this->generateMessageBody($from, $item, $composeMessage));
            }
        } else {
            $endpoint = '/send-sms';
            $data = [
                'sendSmsRequest' => $this->generateMessageBody($from, $numbers[0], $composeMessage),
            ];
        }

        $this->buildCall($endpoint);
        $this->buildBody($data);

        $this->postRequest();
    }
22511
public function send(Message $message) : void
    {
        $destination = $this->getRedirectURL($message);
        Utils::getContainer()->redirect($destination);
    }
613568
public function sendMessage($message)
    {
        if ($payload = $this->getJsonPayload($message)) {
            $response = $this->getHttpClient()
                ->post($this->getWebhook(), [
                    'headers' => ['Content-Type' => 'application/json'],
                    'body' => $payload,
                ]);

            return 200 === $response->getStatusCode();
        }

        return false;
    }
545683
public function send(Message $message)
	{
		$content = $message->generateMessage();

		preg_match('~Message-ID: <(?<message_id>\w+)[^>]+>~', $content, $matches);

		$path = $this->tempDir . '/'. $this->prefix . $matches['message_id'] . '.' . self::FILE_EXTENSION;
		if (($bytes = file_put_contents($path, $content)) === FALSE) {
			throw new InvalidStateException("Unable to write email to '$path'.");
		}

		return $bytes;
	}
516523
public function send(Message $message)
    {
        $rawMessage = $this->getMessageEncoder()->encode($message);

        // test if we need to split the message to multiple chunks
        // chunkSize == 0 allows for an unlimited packet-size, and therefore
        // disables chunking
        if ($this->chunkSize && strlen($rawMessage) > $this->chunkSize) {
            return $this->sendMessageInChunks($rawMessage);
        }

        // send message in one packet
        $this->write($rawMessage);

        return 1;
    }
1316405
protected function sendSwiftMessage($message)
    {
        try {
            return $this->swift->send($message, $this->failedRecipients);
        } finally {
            $this->forceReconnection();
        }
    }
1314946
public function push(QueueMessage $message)
    {
        $queue = $message->getQueueName() ?: $this->queue;

        return $this->client->useTube($queue)->put(
            json_encode($message),
            PheanstalkInterface::DEFAULT_PRIORITY,
            $message->getDelay(),
            $this->timeout
        );
    }
1296958
public function send(OutgoingMessage $message)
    {
        $composeMessage = $message->composeMessage();

        //Convert to sms77 format.
        $numbers = implode(',', $message->getTo());

        $data = [
            'u'     => $this->auth['username'],
            'p'     => $this->auth['password'],
            'to'    => $numbers,
            'from'  => $message->getFrom(),
            'type'  => 'direct',
            'text'  => $composeMessage,
            'debug' => (int) $this->debug,
        ];

        $this->buildCall('');
        $this->buildBody($data);

        $response = $this->postRequest();
        $responseBody = $response->getBody()->read(3);
        if ($this->hasError($responseBody)) {
            $this->handleError($responseBody);
        }

        return $response;
    }
444364
public function send(OutgoingMessage $message)
    {
        $from = $message->getFrom();
        $composeMessage = $message->composeMessage();

        foreach ($message->getTo() as $to) {
            $response = $this->plivo->send_message([
                'dst'  => $to,
                'src'  => $from,
                'text' => $composeMessage,
            ]);

            if ($response['status'] != 202) {
                $this->SMSNotSentException($response['response']['error']);
            }
        }
    }
608077
public function send(OutgoingMessage $message)
    {
        try {
            $message = $this->mailer->send(['text' => $message->getView()], $message->getData(), function ($email) use ($message) {
                $this->generateMessage($email, $message);
            });
        } catch (InvalidArgumentException $e) {
            $message = $this->sendRaw($message);
        }

        return $message;
    }
821166
public function send(MessageInterface $message, &$failures = null)
    {
        return $this->transport->send($message, $failures);
    }
227112
public function sendRequest(array $message): bool
    {
        try {
            $recipient = preg_replace('/\s+/', '', $message['to']) . "@" . $this->endpoint;
            $this->mailer->send($recipient, $message['content']);
            return true;
        } catch (\Exception $e) {
            return false;
        }
    }
1110554
public function send(Message $message)
    {
        $mailer = $this->getMailer();
        $mailer->SetFrom($this->getFrom($message));
        $mailer->AddReplyTo($this->getFrom($message));
        $mailer->Subject = $message->getTitle();
        $mailer->AltBody = strip_tags(preg_replace("/<br.*>/i", "\n", $message->getBody()));
        $mailer->MsgHTML($message->getBody());
        $mailer->AddAddress($this->getUserMail($message->getTo()));

        $result = false;
        try {
            if ($mailer->Send()) {
                $message->setStatus(\oat\tao\model\messaging\Message::STATUS_SENT);
                $result = true;
            }
            if ($mailer->IsError()) {
                $message->setStatus(\oat\tao\model\messaging\Message::STATUS_ERROR);
            }
        } catch (phpmailerException $pe) {
            \common_Logger::e($pe->getMessage());
        }
        $mailer->ClearReplyTos();
        $mailer->ClearAllRecipients();
        $mailer->SmtpClose();

        return $result;
    }
926498
public function reply ($message) {
		// Make sure we actually have a text to reply to
		if (!$this->inbound_message) {
			return false;
		}

		return $this->sendText($this->from, $this->to, $message);
	}