See the official documentation (link below) for usage instructions.
public function send()
{
# Include the Autoloader (see "Libraries" for install instructions)
# Instantiate the client.
$mgClient = new Mailgun('');
$domain = "";
# Make the call to the client.
$result = $mgClient->sendMessage($domain, array('from' => 'InfoJr UFBA <*****@*****.**>', 'to' => 'Você <' . $this->email . '>', 'subject' => 'Capacitação em Git & GitHub - Inscrito', 'text' => $this->name, 'html' => '<html style="width:500px"><style>html{width:500px; text-align:center;} img{width: 100%;} a{padding:5px 15px;}</style><img style="width:100%" src="http://www.infojr.com.br/git-github/assets/img/git-confirm.jpg"></img>
<a style="padding:5px 15px" href="www.infojr.com.br">www.infojr.com.br</a>
<a style="padding:5px 15px" href="www.facebook.com/infojrnews">/infojrnews</a>
</html>'));
return $result;
}
public function setAdressToOkMailGun($recipient)
{
$mgClient = new Mailgun(env('Mailgun_Secret_API_Key', false));
$defaultAddress = env('Mailgun_Forward_Address', false);
$result = $mgClient->post('routes', ['priority' => 2000, 'expression' => 'match_recipient("' . $recipient . '")', 'action' => ['forward("' . $defaultAddress . '")', 'stop()'], 'description' => 'Ok']);
return $result->http_response_code . ': ' . $result->http_response_body->message;
}
/**
* Sends the email through the Mailgun API.
* @return \stdClass the Mailgun API response object.
*/
protected function doSend()
{
if (!$this->getDomain()) {
throw new \Exception('Domain not provided for sending a message through Mailgun. Please set a domain by using the "setDomain($domain)" method.');
}
return $this->client->sendMessage($this->getDomain(), $this->getMessage(), $this->getFiles());
}
public function sendmail($to, $from, $subject, $message)
{
$mgClient = new Mailgun('key-6fe06142d08a9e9c3989f3731bd1d6c0');
$domain = "monithor.net";
# Make the call to the client.
$result = $mgClient->sendMessage($domain, array('from' => $from, 'to' => $to, 'subject' => $subject, 'text' => $message));
}
function email_mailgun($api_key, $api_domain, $params)
{
$_mailgun_api_key = $api_key;
$_mailgun_domain = $api_domain;
$_mailgun_from = $params['from'];
$_mailgun_to = $params['to'];
$_mailgun_subject = $params['subject'];
$_mailgun_text = $params['msg'];
$mg = new Mailgun($_mailgun_api_key);
$domain = $_mailgun_domain;
# Now, compose and send your message.
$mg->sendMessage($domain, array('from' => $_mailgun_from, 'to' => $_mailgun_to, 'subject' => $_mailgun_subject, 'html' => $_mailgun_text));
/* --- COUNTER --- */
/*
$_date = date('Y-m-d');
$_mailgun_count = $_mailgun->count_email($_date);
if($_mailgun_count->rows > 0){
$_mailgun_data = $_mailgun->get_email($_date);
$_mailgun->update_counter($_mailgun_data->date, ($_mailgun_data->counter + 1), $_mailgun_data->status, $_mailgun_data->id);
}else{
$_update->insert_counter($_date, 1, 1);
}
*/
}
public function postSendMail()
{
if (!\Input::has('subject') && !\Input::has('message')) {
return \Response::json(['type' => 'danger', 'message' => 'Email data not complete.']);
}
$recipients = \NewsLetter::getAllRecipients();
if (count($recipients) > 0) {
$recipientsTo = [];
foreach ($recipients as $recipient) {
$recipientsTo[$recipient->email] = ['email' => $recipient->email];
}
try {
$mg = new Mailgun(env('MAILGUN_PRIVATE_KEY'));
$data = ['content' => \Input::get('message')];
$inliner = new EmailInliner('emails.newsletter', $data);
$content = $inliner->convert();
$mg->sendMessage('programmechameleon.com', ['from' => '*****@*****.**', 'to' => implode(",", array_keys($recipientsTo)), 'subject' => \Input::get('subject'), 'html' => $content, 'text' => 'Programme Chameleon Text Message', 'recipient-variables' => json_encode($recipientsTo)]);
return \Response::json(['type' => 'success', 'message' => 'Message successfully sent.']);
} catch (\Exception $e) {
return \Response::json(['type' => 'danger', 'message' => $e->getMessage()]);
}
} else {
return \Response::json(['type' => 'danger', 'message' => 'No emails to send.']);
}
}
public function addList()
{
# Instantiate the client.
$mgClient = new Mailgun('YOUR_API_KEY');
# Issue the call to the client.
$result = $mgClient->post("lists", array('address' => 'LIST@YOUR_DOMAIN_NAME', 'description' => 'Mailgun Dev List'));
}
/**
* Sends an email using MailGun
* @author salvipascual
* @param String $to, email address of the receiver
* @param String $subject, subject of the email
* @param String $body, body of the email in HTML
* @param Array $images, paths to the images to embeb
* @param Array $attachments, paths to the files to attach
* */
public function sendEmail($to, $subject, $body, $images = array(), $attachments = array())
{
// do not email if there is an error
$response = $this->deliveryStatus($to);
if ($response != 'ok') {
return;
}
// select the from email using the jumper
$from = $this->nextEmail($to);
$domain = explode("@", $from)[1];
// create the list of images
if (!empty($images)) {
$images = array('inline' => $images);
}
// crate the list of attachments
// TODO add list of attachments
// create the array send
$message = array("from" => "Apretaste <{$from}>", "to" => $to, "subject" => $subject, "html" => $body, "o:tracking" => false, "o:tracking-clicks" => false, "o:tracking-opens" => false);
// get the key from the config
$di = \Phalcon\DI\FactoryDefault::getDefault();
$mailgunKey = $di->get('config')['mailgun']['key'];
// send the email via MailGun
$mgClient = new Mailgun($mailgunKey);
$result = $mgClient->sendMessage($domain, $message, $images);
}
/**
* Send email via Mailgun
*
* @param CakeEmail $email
* @return array
* @throws Exception
*/
public function send(CakeEmail $email)
{
if (Configure::read('Mailgun.preventManyToRecipients') !== false && count($email->to()) > 1) {
throw new Exception('More than one "to" recipient not allowed (set Mailgun.preventManyToRecipients = false to disable check)');
}
$mgClient = new Mailgun($this->_config['mg_api_key']);
$headersList = array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc', 'subject');
$params = [];
foreach ($email->getHeaders($headersList) as $header => $value) {
if (isset($this->_paramMapping[$header]) && !empty($value)) {
$key = $this->_paramMapping[$header];
$params[$key] = $value;
}
}
$params['text'] = $email->message(CakeEmail::MESSAGE_TEXT);
$params['html'] = $email->message(CakeEmail::MESSAGE_HTML);
$attachments = array();
foreach ($email->attachments() as $name => $info) {
$attachments['attachment'][] = '@' . $info['file'];
}
try {
$result = $mgClient->sendMessage($this->_config['mg_domain'], $params, $attachments);
if ($result->http_response_code != 200) {
throw new Exception($result->http_response_body->message);
}
} catch (Exception $e) {
throw $e;
}
return $result;
}
/**
* Parses an array of email addresses into two lists: parsed addresses and unparsable portions.
* The parsed addresses are a list of addresses that are syntactically valid (and optionally
* have DNS and ESP specific grammar checks).
* The unparsable list is a list of characters sequences that the parser was not able to
* understand. These often align with invalid email addresses, but not always.
*
* @param array|string $addresses
* @param bool $syntaxOnly
*
* @return mixed
*/
public function parse($addresses, $syntaxOnly = false)
{
if (is_array($addresses)) {
$addresses = implode(',', $addresses);
}
$syntaxOnly = $syntaxOnly ? 'true' : 'false';
return $this->mailgun->get('address/parse', ['addresses' => $addresses, 'syntax_only' => $syntaxOnly])->http_response_body;
}
public function sendReceipt(Cart $cart)
{
$mg = new Mailgun(self::API_KEY);
$domain = "mg.fullprintcamping.com";
$user = $cart->user()->first();
$response = $mg->sendMessage($domain, array('from' => '*****@*****.**', 'to' => $user->email, 'subject' => "Your order at FullPrintCamping.com", 'text' => "fullprintcamping.com/order-details/" . $cart->id));
var_dump($response);
}
function SendEmail($to_email, $subject, $mail_text)
{
# Instantiate the client.
$mgClient = new Mailgun('key-9ugjcrpnblx1m98gcpyqejyi75a96ta5');
//$domain = "sandbox40726.mailgun.org";
$domain = "Poolski.com";
# Make the call to the client.
$result = $mgClient->sendMessage("{$domain}", array('from' => 'Poolski <*****@*****.**>', 'to' => $to_email, 'subject' => $subject, 'text' => $mail_text));
}
public function send(Mail $mail)
{
$client = new Client();
$mg = new MG($this->config['mailgun_key'], $client);
$status = $mg->sendMessage($this->config['mailgun_domain'], array('from' => $this->config['from'], 'to' => $mail->to, 'subject' => $mail->subject, 'html' => $mail->content));
if (!$status) {
return false;
}
return true;
}
/**
* Index Page for this controller.
*
* Maps to the following URL
* http://example.com/index.php/welcome
* - or -
* http://example.com/index.php/welcome/index
* - or -
* Since this controller is set as the default controller in
* config/routes.php, it's displayed at http://example.com/
*
* So any other public methods not prefixed with an underscore will
* map to /index.php/welcome/<method_name>
* @see http://codeigniter.com/user_guide/general/urls.html
*/
public function index()
{
$this->load->library('encrypt');
$mg = new Mailgun("key-03bbdd374175cab763318e141fb293ec");
$domain = "sandbox750e37e111ff4d03a61fe980e1f94dee.mailgun.org";
# Now, compose and send your message.
$mg->sendMessage($domain, array('from' => '*****@*****.**', 'to' => '*****@*****.**', 'subject' => 'The PHP SDK is awesome!', 'text' => 'It is so simple to send a message.'));
//print_r($result);
$this->load->view('welcome_message');
}
/**
* Show mailgun status
*
* @return Response
*/
public function __invoke()
{
$mg = new Mailgun(env('MAILGUN_API_KEY'));
$domain = env('MAILGUN_DOMAIN');
//TODO better error handling if mailgun API is not accessible
$logs = $mg->get("{$domain}/log", array('limit' => 16, 'skip' => 0))->http_response_body->items;
$domainResponse = $mg->get("domains/{$domain}");
$domain = $domainResponse->http_response_body->domain;
$responseCode = $domainResponse->http_response_code;
return view('admin.mailgun.index', compact('logs', 'domain', 'responseCode'));
}
/**
*Handler to an event, when a country is not found in the Country Filter of a survey.
*/
public function countryNotFoundHandler($survey_id)
{
# Instantiate the client.
$mgClient = new Mailgun('key-ef43176cf355dd4eab5649acb1c89d0c');
$domain = "hopstek.com";
$to = "*****@*****.**";
$subject = "Country Filter is not working";
$message = "Hi,\r\n\r\n" . "One of the survey's country filter is not working correctly.\r\n\r\n" . "Visit to the survey by clicking on below URL:\r\n\r\n" . "http://" . $_SERVER['HTTP_HOST'] . "/" . str_replace("\\", "/", substr(getcwd(), strlen($_SERVER['DOCUMENT_ROOT']))) . "/view_survey_details.php?survey_id=" . $survey_id . "\r\n\r\n" . "Regards,\r\nSMT";
# Make the call to the client.
$result = $mgClient->sendMessage($domain, array('from' => 'SMT <*****@*****.**>', 'to' => $to, 'subject' => $subject, 'text' => $message));
}
public function sendInviteEmail($to_emails, $from_user, $code, $goupname)
{
$mg = new Mailgun($this->api_key);
$domain = "collabii.com";
$rt = array();
foreach ($to_emails as $email) {
# Now, compose and send your message.
$rt[] = $mg->sendMessage($domain, array('from' => '*****@*****.**', 'to' => $to_emails, 'subject' => 'Collabii Invite From ' . $from_user->get('name'), 'html' => '<img src="http://www.collabii.com/img/logo.png" alt="Collabii"/><p>Hi, ' . $from_user->get('name') . ' has invited you to join a Collabii group. Just click on the invite link below.</p>
<a href="http://www.collabii.com/joingroup/email/' . $code . '">' . $goupname . '</a>'));
}
return $rt;
}
public function validateMailgun($attribute, $value, $parameters)
{
$mgClient = new Mailgun($value);
try {
$result = $mgClient->get("domains");
} catch (\Mailgun\Connection\Exceptions\InvalidCredentials $e) {
return false;
} catch (GenericHTTPError $e) {
return false;
}
return true;
}
public function sendEmail($templateFile)
{
extract($this->data);
# Instantiate the client.
$mgClient = new Mailgun('MAILGUN_KEY');
$domain = MAILGUN_DOMAIN;
ob_start();
include $templateFile;
$emailBody = ob_get_clean();
# Make the call to the client.
$result = $mgClient->sendMessage($domain, array('from' => $emailHeader['from'], 'to' => $emailHeader['to'], 'subject' => $emailHeader['subject'], 'text' => $emailBody));
}
/**
* Implementation of Send method
* ============================
*
* Parse Nette\Mail\Message and send vie Mailgun
* @param \Nette\Mail\Message $mail
*/
public function send(Message $mail)
{
$nMail = clone $mail;
$cFrom = $nMail->getHeader('Return-Path') ?: key($nMail->getHeader('From'));
$to = $this->generateMultiString((array) $nMail->getHeader('To'));
$cc = $this->generateMultiString((array) $nMail->getHeader('Cc'));
$bcc = $this->generateMultiString((array) $nMail->getHeader('Bcc'));
$nMail->setHeader('Bcc', NULL);
$data = $nMail->generateMessage();
$cData = preg_replace('#^\\.#m', '..', $data);
return $this->mg->sendMessage($this->domain, array('from' => $cFrom, 'to' => $to, 'cc' => $cc, 'bcc' => $bcc), $cData);
}
public function sendVerificationEmail($where, $what)
{
# First, instantiate the SDK with your API credentials and define your domain.
$msg = new Mailgun(Config::get('mailgun/secret'));
$domain = Config::get('info/domain');
# Now, compose and send your message.
$msg->sendMessage($domain, array('from' => Config::get('mailgun/from_email'), 'to' => $where, 'subject' => "Your BernBuds email validation code is: {$what}", 'text' => "Your BernBuds email validation code is: {$what}"));
$result = $msg->get("{$domain}/log", array('limit' => 1, 'skip' => 0));
$httpResponseCode = $result->http_response_code;
$httpResponseBody = $result->http_response_body;
return $httpResponseBody;
}
/**
* Send a mail using this transport
*
* @return void
*/
public function sendMessage()
{
// If Mailgun Service is disabled, use the default mail transport
if (!$this->config->enabled()) {
parent::sendMessage();
return;
}
$messageBuilder = $this->createMailgunMessage($this->parseMessage());
$mailgun = new Mailgun($this->config->privateKey(), $this->getHttpClient(), $this->config->endpoint());
$mailgun->setApiVersion($this->config->version());
$mailgun->setSslEnabled($this->config->ssl());
$mailgun->sendMessage($this->config->domain(), $messageBuilder->getMessage(), $messageBuilder->getFiles());
}
public function testShouldAddRecipientVariables()
{
$that = $this;
$this->mailgun->sendMessage('www.example.org', Argument::type('array'), Argument::cetera())->shouldBeCalled()->will(function ($args) use($that) {
$postData = $args[1];
$that->assertArrayHasKey('recipient-variables', $postData);
$that->assertJson($postData['recipient-variables']);
$resp = new \stdClass();
$resp->http_response_code = 200;
return $resp;
});
$this->handler->notify(Email::create()->addVariablesForRecipient('*****@*****.**', ['key' => 'value'])->addTo('*****@*****.**'));
}
public function send(EmailMessage $message, $data = [])
{
$messageData = ['to' => $message->recipients, 'subject' => utf8_encode($message->subject), 'text' => utf8_encode($message->body)];
// Set the mailgun domain
$domain = !empty($data['domain']) ? $data['domain'] : $this->domain;
if (!empty($message->bcc)) {
$messageData['bcc'] = $message->bcc;
}
// Set the from
$messageData['from'] = $message->hasSender() ? utf8_encode($message->getFullSender()) : $this->defaultSender;
// Send the message
$this->mailgun->sendMessage($domain, $messageData);
}
/**
* @param $from
* @param $to
* @param $subject
* @param $text
* @param array $files
* @param null $bcc
* @return bool
*/
public function send($from, $to, $subject, $text, $files = [], $bcc = null)
{
$this->init();
$postData = ['from' => $from, 'to' => $to, 'subject' => $subject, 'html' => $text];
try {
$this->_api->sendMessage($this->domain, $postData, $files);
} catch (\Exception $e) {
\Yii::error('Send error: ' . $e->getMessage(), 'email\\MailGun');
\Yii::trace(VarDumper::dumpAsString($postData), 'email\\MailGun');
return false;
}
return true;
}
/**
* @inheritdoc
*/
public function send(MessageInterface $message)
{
$httpClient = new \Http\Adapter\Guzzle6\Client();
$mg = new Mailgun($this->apiKey, $httpClient);
list($name, $domain) = explode('@', $message->getFromPerson()->getEmail());
# Now, compose and send your message.
try {
$response = $mg->sendMessage($domain, ['sender' => $message->getFromPerson()->getEmail(), 'from' => $this->nameWithEmail($message->getFromPerson()->getEmail(), $message->getFromPerson()->getFullName()), 'to' => $message->getToPerson()->getEmail(), 'subject' => $message->getSubject(), 'html' => $message->getHtmlContent(), 'text' => $message->getTextContent()]);
$result = new SendingResult($response);
} catch (\Exception $e) {
$result = new SendingResult();
}
return $result;
}
/**
* @param int $id
* @return CampaignStats
*/
public function find($id)
{
$mg = new Mailgun($this->key);
$result = $mg->get($this->domain . '/campaigns/' . $id);
$stats = $result->http_response_body;
$data['clicked'] = $stats->clicked_count;
$data['opened'] = $stats->opened_count;
$data['submitted'] = $stats->submitted_count;
$data['unsubscribed'] = $stats->unsubscribed_count;
$data['bounced'] = $stats->bounced_count;
$data['delivered'] = $stats->delivered_count;
$data['complained'] = $stats->complained_count;
$data['dropped'] = $stats->dropped_count;
return new CampaignStats($data);
}
public static function sendToAdmin(array $data)
{
// Define properties
$data = self::sanitize($data);
$site = get_option("blogname");
$from = "System Message <" . get_option("admin_email") . ">";
$to = get_option("admin_email");
// Create text
$subject = "Customer used form on the site \"{$site}\"";
$message = Template::renderPart("email/form", ['site' => $site, 'data' => $data]);
// Send mail
$Mailgun = new Mailgun(get_option("mailgun_key"));
$result = $Mailgun->sendMessage(get_option("mailgun_domain"), ['from' => $from, 'to' => $to, 'subject' => $subject, 'html' => $message]);
// Return sending result
return $result;
}
public function listremoveAction($listname)
{
$mailgun = new Mailgun($this->private_key, $this->APIURL, "v3", true);
$listAddress = $listname . $this->GROUPEMAIL;
$result = $mailgun->delete("lists/{$listAddress}");
return $this->JsonResponse($result);
}
/**
* {@inheritDoc}
*/
public function send(EmailEntity $email)
{
$time = time();
$message = $this->buildMessage($email);
// Get domain from the "from" address
if (!preg_match('/@(.+)$/', $email->getSenderEmail(), $matches)) {
throw new \Exception("Invalid from address: {$email->getSenderEmail()}");
}
$domain = $matches[1];
$result = $this->mailgun->sendMessage($domain, $message);
$email->setStatus($result->http_response_code === 200 ? 'sent' : 'error');
$email->setSent($time);
$email->setUpdated($time);
$this->mapper->update($email);
return [$email, $result];
}
