bachir/materio-base-legacy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added mailgun librarie

Browse Source
This commit is contained in:
Bachir Soussi Chiadmi 2016-07-19 19:58:07 +02:00
parent deae7e0b59
commit 918b4cd5e1
18 changed files with 275 additions and 753 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
sites/all/libraries/mailgun/.travis.yml
View File

@ -1,16 +1,16 @@
language: php
php:
- 5.3
- 5.4
- 5.5
- 5.6
- 7.0
- hhvm
before_install:
- travis_retry composer self-update
matrix:
allow_failures:
- php: hhvm
install:
- travis_retry composer install
script:
- phpunit
before_script:
- echo 'Installing composer dependencies now!'
- composer install

39
sites/all/libraries/mailgun/README.md
View File

@ -22,32 +22,12 @@ composer and the Mailgun SDK.
curl -sS https://getcomposer.org/installer | php
# Add Mailgun as a dependency
php composer.phar require mailgun/mailgun-php:~2.0
```
You do also need to choose what library to use when you are sending http messages. Consult the
[php-http/client-implementation](https://packagist.org/providers/php-http/client-implementation) virtual package to
find adapters to use. For more information about virtual packages please refer to
[Httplug](http://docs.httplug.io/en/latest/virtual-package/). Example:
```bash
php composer.phar require php-http/guzzle6-adapter:^1.0
```
When creating a new `Mailgun` object you must provide an instance of the `HttpClient`.
```php
$client = new \Http\Adapter\Guzzle6\Client();
$mailgun = new \Mailgun\Mailgun('api_key', $client);
```
You could also rely on the [auto discovery feature of Httplug](http://docs.php-http.org/en/latest/discovery.html). This
means that you need to install `puli/composer-plugin` and put a puli.phar in your project root.
php composer.phar require mailgun/mailgun-php:~1.7.1
```
**For shared hosts without SSH access, check out our [Shared Host Instructions](SharedHostInstall.md).**
**Rather just download the files? [Library Download](https://9f67cbbd1116d8afb399-7760483f5d1e5f28c2d253278a2a5045.ssl.cf2.rackcdn.com/mailgun-php-1.7.2.zip).**
**Rather just download the files? [Library Download](https://9f67cbbd1116d8afb399-7760483f5d1e5f28c2d253278a2a5045.ssl.cf2.rackcdn.com/mailgun-php-1.7.1.zip).**
Next, require Composer's autoloader, in your application, to automatically
load the Mailgun SDK in your project:
@ -161,9 +141,7 @@ Go to http://bin.mailgun.net. The Postbin will generate a special URL. Save that
```php
# First, instantiate the SDK with your API credentials and define your domain.
$mg = new Mailgun('key-example', null, 'bin.mailgun.net');
$mg->setApiVersion('aecf68de');
$mg->setSslEnabled('false');
$mg = new Mailgun('key-example', 'bin.mailgun.net', 'aecf68de', $ssl = False);
$domain = 'example.com';
# Now, compose and send your message.
@ -187,15 +165,6 @@ Batch Message is an extension of Message Builder, and allows you to easily send
a batch message job within a few seconds. The complexity of
batch messaging is eliminated!
Framework integration
---------------------
If you are using a framework you might consider these composer packages to make the framework integration easier.
* [tehplague/swiftmailer-mailgun-bundle](https://github.com/tehplague/swiftmailer-mailgun-bundle) for Symfony2
* [Bogardo/Mailgun](https://github.com/Bogardo/Mailgun) for Laravel 4
* [katanyoo/yii2-mailgun-mailer](https://github.com/katanyoo/yii2-mailgun-mailer) for Yii2
Support and Feedback
--------------------

4
sites/all/libraries/mailgun/SharedHostInstall.md
View File

@ -11,7 +11,7 @@ Linux / Mac OSX:
*PHP is typically installed by default, consult your distribution documentation. Instructions from [getcomposer.org](http://getcomposer.org/doc/00-intro.md#installation-nix).*
1. curl -sS https://getcomposer.org/installer | php
2. php composer.phar require mailgun/mailgun-php:~1.7.2
2. php composer.phar require mailgun/mailgun-php:~1.7.1
3. The files will be downloaded to your local computer.
4. Upload the files to your webserver.
@ -20,7 +20,7 @@ Windows:
*PHP must be installed on your computer, [download](http://windows.php.net/download/0). Instructions from [getcomposer.org](http://getcomposer.org/doc/00-intro.md#installation-windows).*
1. Download and run [Composer-Setup.exe](https://getcomposer.org/Composer-Setup.exe).
2. Open a Command Prompt and type "php composer require mailgun/mailgun-php:~1.7.2".
2. Open a Command Prompt and type "php composer require mailgun/mailgun-php:~1.7.1".
3. The files will be downloaded to your local computer.
4. Upload the files to your webserver.

8
sites/all/libraries/mailgun/composer.json
View File

@ -2,14 +2,10 @@
"name": "mailgun/mailgun-php",
"description": "The Mailgun SDK provides methods for all API functions.",
"require": {
"php": "^5.5|^7.0",
"guzzlehttp/psr7": "~1.2",
"php-http/httplug": "^1.0",
"php-http/discovery": "^0.8"
"guzzle/guzzle": "<4.0,>=3.8"
},
"require-dev": {
"phpunit/phpunit": "~4.6",
"php-http/guzzle6-adapter": "^1.0"
"phpunit/phpunit": "3.7.*"
},
"autoload": {
"psr-0": {

424
sites/all/libraries/mailgun/src/Mailgun/Connection/RestClient.php
View File

@ -2,325 +2,149 @@
namespace Mailgun\Connection;
use GuzzleHttp\Psr7\MultipartStream;
use GuzzleHttp\Psr7\Request;
use Http\Client\HttpClient;
use Http\Discovery\HttpClientDiscovery;
use Guzzle\Http\Client as Guzzle;
use Mailgun\MailgunClient;
use Mailgun\Connection\Exceptions\GenericHTTPError;
use Guzzle\Http\QueryAggregator\DuplicateAggregator;
use Guzzle\Http\QueryAggregator\PhpAggregator;
use Mailgun\Connection\Exceptions\InvalidCredentials;
use Mailgun\Connection\Exceptions\NoDomainsConfigured;
use Mailgun\Connection\Exceptions\MissingRequiredParameters;
use Mailgun\Connection\Exceptions\MissingEndpoint;
use Mailgun\Constants\Api;
use Mailgun\Constants\ExceptionMessages;
use Psr\Http\Message\ResponseInterface;
/**
* This class is a wrapper for the Guzzle (HTTP Client Library).
*/
class RestClient
{
/**
* Your API key
* @var string
*/
private $apiKey;
/*
This class is a wrapper for the Guzzle (HTTP Client Library).
*/
/**
* @var HttpClient
*/
protected $httpClient;
class RestClient{
/**
* @var string
*/
protected $apiHost;
private $apiKey;
protected $mgClient;
protected $hasFiles = False;
/**
* The version of the API to use
* @var string
*/
protected $apiVersion = 'v2';
public function __construct($apiKey, $apiEndpoint, $apiVersion, $ssl){
$this->apiKey = $apiKey;
$this->mgClient = new Guzzle($this->generateEndpoint($apiEndpoint, $apiVersion, $ssl));
$this->mgClient->setDefaultOption('curl.options', array('CURLOPT_FORBID_REUSE' => true));
$this->mgClient->setDefaultOption('auth', array (API_USER, $this->apiKey));
$this->mgClient->setDefaultOption('exceptions', false);
$this->mgClient->setUserAgent(SDK_USER_AGENT . '/' . SDK_VERSION);
}
/**
* If we should use SSL or not
* @var bool
*/
protected $sslEnabled = true;
public function post($endpointUrl, $postData = array(), $files = array()){
$request = $this->mgClient->post($endpointUrl, array(), $postData);
/**
* @param string $apiKey
* @param string $apiHost
* @param HttpClient $httpClient
*/
public function __construct($apiKey, $apiHost, HttpClient $httpClient = null)
{
$this->apiKey = $apiKey;
$this->apiHost = $apiHost;
$this->httpClient = $httpClient;
}
if(isset($files["message"])){
$this->hasFiles = True;
foreach($files as $message){
$request->addPostFile("message", $message);
}
}
/**
* @param string $method
* @param string $uri
* @param array $body
* @param array $files
* @param array $headers
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
protected function send($method, $uri, $body = null, $files = [], array $headers = [])
{
$headers['User-Agent'] = Api::SDK_USER_AGENT.'/'.Api::SDK_VERSION;
$headers['Authorization'] = 'Basic '.base64_encode(sprintf('%s:%s', Api::API_USER, $this->apiKey));
if(isset($files["attachment"])){
$this->hasFiles = True;
foreach($files["attachment"] as $attachment){
// Backward compatibility code
if (is_array($attachment)){
$request->addPostFile("attachment",
$attachment['filePath'], null,
$attachment['remoteName']);
}
else{
$request->addPostFile("attachment", $attachment);
}
}
}
if (!empty($files)) {
$body = new MultipartStream($files);
$headers['Content-Type'] = 'multipart/form-data; boundary='.$body->getBoundary();
}
if(isset($files["inline"])){
$this->hasFiles = True;
foreach($files["inline"] as $inline){
// Backward compatibility code
if (is_array($inline)){
$request->addPostFile("inline",
$inline['filePath'], null,
$inline['remoteName']);
}
else{
$request->addPostFile("inline", $inline);
}
}
}
$request = new Request($method, $this->getApiUrl($uri), $headers, $body);
$response = $this->getHttpClient()->sendRequest($request);
/*
This block of code is to accommodate for a bug in Guzzle.
See https://github.com/guzzle/guzzle/issues/545.
It can be removed when Guzzle resolves the issue.
*/
return $this->responseHandler($response);
}
if($this->hasFiles){
$request->getPostFields()->setAggregator(new PhpAggregator());
}
/**
* @param string $endpointUrl
* @param array $postData
* @param array $files
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
public function post($endpointUrl, $postData = array(), $files = array())
{
$postFiles = [];
else{
$request->getPostFields()->setAggregator(new DuplicateAggregator());
}
$fields = ['message', 'attachment', 'inline'];
foreach ($fields as $fieldName) {
if (isset($files[$fieldName])) {
if (is_array($files[$fieldName])) {
foreach ($files[$fieldName] as $file) {
$postFiles[] = $this->prepareFile($fieldName, $file);
}
} else {
$postFiles[] = $this->prepareFile($fieldName, $files[$fieldName]);
}
}
}
$response = $request->send();
return $this->responseHandler($response);
}
$postDataMultipart = [];
foreach ($postData as $key => $value) {
if (is_array($value)) {
foreach ($value as $subValue) {
$postDataMultipart[] = [
'name' => $key,
'contents' => $subValue,
];
}
} else {
$postDataMultipart[] = [
'name' => $key,
'contents' => $value,
];
}
}
public function get($endpointUrl, $queryString = array()){
$request = $this->mgClient->get($endpointUrl);
if(isset($queryString)){
foreach($queryString as $key=>$value){
$request->getQuery()->set($key, $value);
}
}
$response = $request->send();
return $this->responseHandler($response);
}
return $this->send('POST', $endpointUrl, [], array_merge($postDataMultipart, $postFiles));
}
public function delete($endpointUrl){
$request = $this->mgClient->delete($endpointUrl);
$response = $request->send();
return $this->responseHandler($response);
}
/**
* @param string $endpointUrl
* @param array $queryString
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
public function get($endpointUrl, $queryString = array())
{
return $this->send('GET', $endpointUrl.'?'.http_build_query($queryString));
}
public function put($endpointUrl, $putData){
$request = $this->mgClient->put($endpointUrl, array(), $putData);
$request->getPostFields()->setAggregator(new DuplicateAggregator());
$response = $request->send();
return $this->responseHandler($response);
}
/**
* @param string $endpointUrl
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
public function delete($endpointUrl)
{
return $this->send('DELETE', $endpointUrl);
}
public function responseHandler($responseObj){
$httpResponseCode = $responseObj->getStatusCode();
if($httpResponseCode === 200){
$data = (string) $responseObj->getBody();
$jsonResponseData = json_decode($data, false);
$result = new \stdClass();
// return response data as json if possible, raw if not
$result->http_response_body = $data && $jsonResponseData === null ? $data : $jsonResponseData;
}
elseif($httpResponseCode == 400){
throw new MissingRequiredParameters(EXCEPTION_MISSING_REQUIRED_PARAMETERS);
}
elseif($httpResponseCode == 401){
throw new InvalidCredentials(EXCEPTION_INVALID_CREDENTIALS);
}
elseif($httpResponseCode == 404){
throw new MissingEndpoint(EXCEPTION_MISSING_ENDPOINT);
}
else{
throw new GenericHTTPError(EXCEPTION_GENERIC_HTTP_ERROR, $httpResponseCode, $responseObj->getBody());
}
$result->http_response_code = $httpResponseCode;
return $result;
}
/**
* @param string $endpointUrl
* @param array $putData
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
public function put($endpointUrl, $putData)
{
return $this->send('PUT', $endpointUrl, $putData);
}
/**
* @param ResponseInterface $responseObj
*
* @return \stdClass
*
* @throws GenericHTTPError
* @throws InvalidCredentials
* @throws MissingEndpoint
* @throws MissingRequiredParameters
*/
public function responseHandler(ResponseInterface $responseObj)
{
$httpResponseCode = $responseObj->getStatusCode();
if ($httpResponseCode === 200) {
$data = (string) $responseObj->getBody();
$jsonResponseData = json_decode($data, false);
$result = new \stdClass();
// return response data as json if possible, raw if not
$result->http_response_body = $data && $jsonResponseData === null ? $data : $jsonResponseData;
} elseif ($httpResponseCode == 400) {
throw new MissingRequiredParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_PARAMETERS.$this->getResponseExceptionMessage($responseObj));
} elseif ($httpResponseCode == 401) {
throw new InvalidCredentials(ExceptionMessages::EXCEPTION_INVALID_CREDENTIALS);
} elseif ($httpResponseCode == 404) {
throw new MissingEndpoint(ExceptionMessages::EXCEPTION_MISSING_ENDPOINT.$this->getResponseExceptionMessage($responseObj));
} else {
throw new GenericHTTPError(ExceptionMessages::EXCEPTION_GENERIC_HTTP_ERROR, $httpResponseCode, $responseObj->getBody());
}
$result->http_response_code = $httpResponseCode;
return $result;
}
/**
* @param ResponseInterface $responseObj
*
* @return string
*/
protected function getResponseExceptionMessage(ResponseInterface $responseObj)
{
$body = (string) $responseObj->getBody();
$response = json_decode($body);
if (json_last_error() == JSON_ERROR_NONE && isset($response->message)) {
return ' '.$response->message;
}
}
/**
* Prepare a file for the postBody.
*
* @param string $fieldName
* @param string|array $filePath
*/
protected function prepareFile($fieldName, $filePath)
{
$filename = null;
// Backward compatibility code
if (is_array($filePath)) {
$filename = $filePath['remoteName'];
$filePath = $filePath['filePath'];
}
// Remove leading @ symbol
if (strpos($filePath, '@') === 0) {
$filePath = substr($filePath, 1);
}
return [
'name' => $fieldName,
'contents' => fopen($filePath, 'r'),
'filename' => $filename,
];
}
/**
*
* @return HttpClient
*/
protected function getHttpClient()
{
if ($this->httpClient === null) {
$this->httpClient = HttpClientDiscovery::find();
}
return $this->httpClient;
}
/**
* @param $uri
*
* @return string
*/
private function getApiUrl($uri)
{
return $this->generateEndpoint($this->apiHost, $this->apiVersion, $this->sslEnabled).$uri;
}
/**
* @param string $apiEndpoint
* @param string $apiVersion
* @param bool $ssl
*
* @return string
*/
private function generateEndpoint($apiEndpoint, $apiVersion, $ssl)
{
if (!$ssl) {
return 'http://'.$apiEndpoint.'/'.$apiVersion.'/';
} else {
return 'https://'.$apiEndpoint.'/'.$apiVersion.'/';
}
}
/**
* @param string $apiVersion
*
* @return RestClient
*/
public function setApiVersion($apiVersion)
{
$this->apiVersion = $apiVersion;
return $this;
}
/**
* @param boolean $sslEnabled
*
* @return RestClient
*/
public function setSslEnabled($sslEnabled)
{
$this->sslEnabled = $sslEnabled;
return $this;
}
private function generateEndpoint($apiEndpoint, $apiVersion, $ssl){
if(!$ssl){
return "http://" . $apiEndpoint . "/" . $apiVersion . "/";
}
else{
return "https://" . $apiEndpoint . "/" . $apiVersion . "/";
}
}
}

16
sites/all/libraries/mailgun/src/Mailgun/Constants/Api.php
View File

@ -1,16 +0,0 @@
<?php
namespace Mailgun\Constants;
class Api {
const API_USER = "api";
const SDK_VERSION = "1.7";
const SDK_USER_AGENT = "mailgun-sdk-php";
const RECIPIENT_COUNT_LIMIT = 1000;
const CAMPAIGN_ID_LIMIT = 3;
const TAG_LIMIT = 3;
const DEFAULT_TIME_ZONE = "UTC";
}

23
sites/all/libraries/mailgun/src/Mailgun/Constants/Constants.php Normal file
View File

@ -0,0 +1,23 @@
<?PHP
const API_USER = "api";
const SDK_VERSION = "1.7";
const SDK_USER_AGENT = "mailgun-sdk-php";
const RECIPIENT_COUNT_LIMIT = 1000;
const CAMPAIGN_ID_LIMIT = 3;
const TAG_LIMIT = 3;
const DEFAULT_TIME_ZONE = "UTC";
//Common Exception Messages
const EXCEPTION_INVALID_CREDENTIALS = "Your credentials are incorrect.";
const EXCEPTION_GENERIC_HTTP_ERROR = "An HTTP Error has occurred! Check your network connection and try again.";
const EXCEPTION_MISSING_REQUIRED_PARAMETERS = "The parameters passed to the API were invalid. Check your inputs!";
const EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS = "The parameters passed to the API were invalid. Check your inputs!";
const EXCEPTION_MISSING_ENDPOINT = "The endpoint you've tried to access does not exist. Check your URL.";
const TOO_MANY_RECIPIENTS = "You've exceeded the maximum recipient count (1,000) on the to field with autosend disabled.";
const INVALID_PARAMETER_NON_ARRAY = "The parameter you've passed in position 2 must be an array.";
const INVALID_PARAMETER_ATTACHMENT = "Attachments must be passed with an \"@\" preceding the file path. Web resources not supported.";
const INVALID_PARAMETER_INLINE = "Inline images must be passed with an \"@\" preceding the file path. Web resources not supported.";
const TOO_MANY_PARAMETERS_CAMPAIGNS = "You've exceeded the maximum (3) campaigns for a single message.";
const TOO_MANY_PARAMETERS_TAGS = "You've exceeded the maximum (3) tags for a single message.";
const TOO_MANY_PARAMETERS_RECIPIENT = "You've exceeded the maximum recipient count (1,000) on the to field with autosend disabled.";

21
sites/all/libraries/mailgun/src/Mailgun/Constants/ExceptionMessages.php
View File

@ -1,21 +0,0 @@
<?php
namespace Mailgun\Constants;
class ExceptionMessages {
const EXCEPTION_INVALID_CREDENTIALS = "Your credentials are incorrect.";
const EXCEPTION_GENERIC_HTTP_ERROR = "An HTTP Error has occurred! Check your network connection and try again.";
const EXCEPTION_MISSING_REQUIRED_PARAMETERS = "The parameters passed to the API were invalid. Check your inputs!";
const EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS = "The parameters passed to the API were invalid. Check your inputs!";
const EXCEPTION_MISSING_ENDPOINT = "The endpoint you've tried to access does not exist. Check your URL.";
const TOO_MANY_RECIPIENTS = "You've exceeded the maximum recipient count (1,000) on the to field with autosend disabled.";
const INVALID_PARAMETER_NON_ARRAY = "The parameter you've passed in position 2 must be an array.";
const INVALID_PARAMETER_ATTACHMENT = "Attachments must be passed with an \"@\" preceding the file path. Web resources not supported.";
const INVALID_PARAMETER_INLINE = "Inline images must be passed with an \"@\" preceding the file path. Web resources not supported.";
const TOO_MANY_PARAMETERS_CAMPAIGNS = "You've exceeded the maximum (3) campaigns for a single message.";
const TOO_MANY_PARAMETERS_TAGS = "You've exceeded the maximum (3) tags for a single message.";
const TOO_MANY_PARAMETERS_RECIPIENT = "You've exceeded the maximum recipient count (1,000) on the to field with autosend disabled.";
}

26
sites/all/libraries/mailgun/src/Mailgun/Lists/OptInHandler.php
View File

@ -6,20 +6,17 @@ use Mailgun\Messages\Exceptions\InvalidParameter;
use Mailgun\Messages\Exceptions\TooManyParameters;
use Mailgun\Messages\Expcetions\InvalidParameterType;
/**
* This class is used for creating a unique hash for
* mailing list subscription double-opt in requests.
*
* @link https://github.com/mailgun/mailgun-php/blob/master/src/Mailgun/Lists/README.md
*/
/*
This class is used for creating a unique hash for
mailing list subscription double-opt in requests.
*/
class OptInHandler{
/**
* @param string $mailingList
* @param string $secretAppId
* @param string $recipientAddress
* @return string
*/
function __construct(){
}
public function generateHash($mailingList, $secretAppId, $recipientAddress){
$innerPayload = array('r' => $recipientAddress, 'l' => $mailingList);
$encodedInnerPayload = base64_encode(json_encode($innerPayload));
@ -30,11 +27,6 @@ class OptInHandler{
return urlencode(base64_encode(json_encode($outerPayload)));
}
/**
* @param string $secretAppId
* @param string $uniqueHash
* @return array|bool
*/
public function validateHash($secretAppId, $uniqueHash){
$decodedOuterPayload = json_decode(base64_decode(urldecode($uniqueHash)), true);

137
sites/all/libraries/mailgun/src/Mailgun/Mailgun.php
View File

@ -2,57 +2,36 @@
namespace Mailgun;
use Http\Client\HttpClient;
use Mailgun\Constants\ExceptionMessages;
require_once 'Constants/Constants.php';
use Mailgun\Messages\Messages;
use Mailgun\Messages\Exceptions;
use Mailgun\Connection\RestClient;
use Mailgun\Messages\BatchMessage;
use Mailgun\Lists\OptInHandler;
use Mailgun\Messages\MessageBuilder;
/**
* This class is the base class for the Mailgun SDK.
* See the official documentation (link below) for usage instructions.
*
* @link https://github.com/mailgun/mailgun-php/blob/master/README.md
*/
/*
This class is the base class for the Mailgun SDK.
See the official documentation for usage instructions.
*/
class Mailgun{
/**
* @var RestClient
*/
protected $workingDomain;
protected $restClient;
/**
* @var null|string
*/
protected $apiKey;
/**
* @param string|null $apiKey
* @param HttpClient $httpClient
* @param string $apiEndpoint
*/
public function __construct(
$apiKey = null,
HttpClient $httpClient = null,
$apiEndpoint = 'api.mailgun.net'
) {
public function __construct($apiKey = null, $apiEndpoint = "api.mailgun.net", $apiVersion = "v2", $ssl = true){
$this->apiKey = $apiKey;
$this->restClient = new RestClient($apiKey, $apiEndpoint, $httpClient);
$this->restClient = new RestClient($apiKey, $apiEndpoint, $apiVersion, $ssl);
}
/**
* This function allows the sending of a fully formed message OR a custom
* MIME string. If sending MIME, the string must be passed in to the 3rd
* position of the function call.
*
* @param string $workingDomain
* @param array $postData
* @param array $postFiles
* @throws Exceptions\MissingRequiredMIMEParameters
*/
public function sendMessage($workingDomain, $postData, $postFiles = array()){
/*
* This function allows the sending of a fully formed message OR a custom
* MIME string. If sending MIME, the string must be passed in to the 3rd
* position of the function call.
*/
if(is_array($postFiles)){
return $this->post("$workingDomain/messages", $postData, $postFiles);
}
@ -68,24 +47,21 @@ class Mailgun{
return $result;
}
else{
throw new Exceptions\MissingRequiredMIMEParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
throw new Exceptions\MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
}
}
/**
* This function checks the signature in a POST request to see if it is
* authentic.
*
* Pass an array of parameters. If you pass nothing, $_POST will be
* used instead.
*
* If this function returns FALSE, you must not process the request.
* You should reject the request with status code 403 Forbidden.
*
* @param array|null $postData
* @return bool
*/
public function verifyWebhookSignature($postData = NULL) {
/*
* This function checks the signature in a POST request to see if it is
* authentic.
*
* Pass an array of parameters. If you pass nothing, $_POST will be
* used instead.
*
* If this function returns FALSE, you must not process the request.
* You should reject the request with status code 403 Forbidden.
*/
if(is_null($postData)) {
$postData = $_POST;
}
@ -100,85 +76,30 @@ class Mailgun{
}
}
/**
* @param string $endpointUrl
* @param array $postData
* @param array $files
* @return \stdClass
*/
public function post($endpointUrl, $postData = array(), $files = array()){
return $this->restClient->post($endpointUrl, $postData, $files);
}
/**
* @param string $endpointUrl
* @param array $queryString
* @return \stdClass
*/
public function get($endpointUrl, $queryString = array()){
return $this->restClient->get($endpointUrl, $queryString);
}
/**
* @param string $endpointUrl
* @return \stdClass
*/
public function delete($endpointUrl){
return $this->restClient->delete($endpointUrl);
}
/**
* @param string $endpointUrl
* @param array $putData
* @return \stdClass
*/
public function put($endpointUrl, $putData){
return $this->restClient->put($endpointUrl, $putData);
}
/**
* @param string $apiVersion
*
* @return Mailgun
*/
public function setApiVersion($apiVersion)
{
$this->restClient->setApiVersion($apiVersion);
return $this;
}
/**
* @param boolean $sslEnabled
*
* @return Mailgun
*/
public function setSslEnabled($sslEnabled)
{
$this->restClient->setSslEnabled($sslEnabled);
return $this;
}
/**
* @return MessageBuilder
*/
public function MessageBuilder(){
return new MessageBuilder();
}
/**
* @return OptInHandler
*/
public function OptInHandler(){
return new OptInHandler();
}
/**
* @param string $workingDomain
* @param bool $autoSend
* @return BatchMessage
*/
public function BatchMessage($workingDomain, $autoSend = true){
return new BatchMessage($this->restClient, $workingDomain, $autoSend);
}

70
sites/all/libraries/mailgun/src/Mailgun/Messages/BatchMessage.php
View File

@ -2,49 +2,23 @@
namespace Mailgun\Messages;
use Mailgun\Constants\Api;
use Mailgun\Constants\ExceptionMessages;
use Mailgun\Messages\MessageBuilder;
use Mailgun\Messages\Exceptions\TooManyParameters;
use Mailgun\Messages\Exceptions\MissingRequiredMIMEParameters;
/**
* This class is used for batch sending. See the official documentation (link below)
* for usage instructions.
*
* @link https://github.com/mailgun/mailgun-php/blob/master/src/Mailgun/Messages/README.md
*/
/*
This class is used for batch sending. See the official documentation
for usage instructions.
*/
class BatchMessage extends MessageBuilder{
/**
* @var array
*/
private $batchRecipientAttributes;
/**
* @var boolean
*/
private $autoSend;
/**
* @var \Mailgun\Connection\RestClient
*/
private $restClient;
/**
* @var string
*/
private $workingDomain;
/**
* @var array
*/
private $messageIds = array();
/**
* @param \Mailgun\Connection\RestClient $restClient
* @param string $workingDomain
* @param boolean $autoSend
*/
public function __construct($restClient, $workingDomain, $autoSend){
$this->batchRecipientAttributes = array();
$this->autoSend = $autoSend;
@ -53,18 +27,11 @@ class BatchMessage extends MessageBuilder{
$this->endpointUrl = $workingDomain . "/messages";
}
/**
* @param string $headerName
* @param string $address
* @param array $variables
* @throws MissingRequiredMIMEParameters
* @throws TooManyParameters
*/
protected function addRecipient($headerName, $address, $variables){
if(array_key_exists($headerName, $this->counters['recipients'])){
if($this->counters['recipients'][$headerName] == Api::RECIPIENT_COUNT_LIMIT){
if($this->counters['recipients'][$headerName] == RECIPIENT_COUNT_LIMIT){
if($this->autoSend == false){
throw new TooManyParameters(ExceptionMessages::TOO_MANY_RECIPIENTS);
throw new TooManyParameters(TOO_MANY_RECIPIENTS);
}
$this->sendMessage();
}
@ -91,27 +58,22 @@ class BatchMessage extends MessageBuilder{
$this->batchRecipientAttributes["$address"] = $variables;
}
/**
* @param array $message
* @param array $files
* @throws MissingRequiredMIMEParameters
*/
public function sendMessage($message = array(), $files = array()){
if(count($message) < 1){
$message = $this->message;
$files = $this->files;
}
if(!array_key_exists("from", $message)){
throw new MissingRequiredMIMEParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
throw new MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
}
elseif(!array_key_exists("to", $message)){
throw new MissingRequiredMIMEParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
throw new MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
}
elseif(!array_key_exists("subject", $message)){
throw new MissingRequiredMIMEParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
throw new MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
}
elseif((!array_key_exists("text", $message) && !array_key_exists("html", $message))){
throw new MissingRequiredMIMEParameters(ExceptionMessages::EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
throw new MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
}
else{
$message["recipient-variables"] = json_encode($this->batchRecipientAttributes);
@ -125,16 +87,10 @@ class BatchMessage extends MessageBuilder{
}
}
/**
* @throws MissingRequiredMIMEParameters
*/
public function finalize(){
$this->sendMessage();
return $this->sendMessage();
}
/**
* @return string[]
*/
public function getMessageIds(){
return $this->messageIds;
}

183
sites/all/libraries/mailgun/src/Mailgun/Messages/MessageBuilder.php
View File

@ -2,39 +2,23 @@
namespace Mailgun\Messages;
use Mailgun\Constants\Api;
use Mailgun\Constants\ExceptionMessages;
use Mailgun\Messages\Exceptions\InvalidParameter;
use Mailgun\Messages\Exceptions\TooManyParameters;
use Mailgun\Messages\Exceptions\InvalidParameterType;
/*
This class is used for composing a properly formed
message object. Dealing with arrays can be cumbersome,
this class makes the process easier. See the official
documentation for usage instructions.
*/
/**
* This class is used for composing a properly formed
* message object. Dealing with arrays can be cumbersome,
* this class makes the process easier. See the official
* documentation (link below) for usage instructions.
*
* @link https://github.com/mailgun/mailgun-php/blob/master/src/Mailgun/Messages/README.md
*/
class MessageBuilder
{
/**
* @var array
*/
protected $message = array();
/**
* @var array
*/
protected $variables = array();
/**
* @var array
*/
protected $files = array();
/**
* @var array
*/
protected $counters = array(
'recipients' => array(
'to' => 0,
@ -49,12 +33,6 @@ class MessageBuilder
)
);
/**
* @param array $params
* @param string $key
* @param mixed $default
* @return mixed
*/
protected function safeGet($params, $key, $default)
{
if (array_key_exists($key, $params)) {
@ -64,10 +42,6 @@ class MessageBuilder
return $default;
}
/**
* @param array $params
* @return mixed|string
*/
protected function getFullName($params)
{
if (array_key_exists("first", $params)) {
@ -80,11 +54,6 @@ class MessageBuilder
return $this->safeGet($params, "full_name", "");
}
/**
* @param string $address
* @param array $variables
* @return string
*/
protected function parseAddress($address, $variables)
{
if (!is_array($variables)) {
@ -98,11 +67,6 @@ class MessageBuilder
return $address;
}
/**
* @param string $headerName
* @param string $address
* @param array $variables
*/
protected function addRecipient($headerName, $address, $variables)
{
$compiledAddress = $this->parseAddress($address, $variables);
@ -119,59 +83,36 @@ class MessageBuilder
}
}
/**
* @param string $address
* @param array|null $variables
* @return mixed
* @throws TooManyParameters
*/
public function addToRecipient($address, $variables = null)
{
if ($this->counters['recipients']['to'] > Api::RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(ExceptionMessages::TOO_MANY_PARAMETERS_RECIPIENT);
if ($this->counters['recipients']['to'] > RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(TOO_MANY_PARAMETERS_RECIPIENT);
}
$this->addRecipient("to", $address, $variables);
return end($this->message['to']);
}
/**
* @param string $address
* @param array|null $variables
* @return mixed
* @throws TooManyParameters
*/
public function addCcRecipient($address, $variables = null)
{
if ($this->counters['recipients']['cc'] > Api::RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(ExceptionMessages::TOO_MANY_PARAMETERS_RECIPIENT);
if ($this->counters['recipients']['cc'] > RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(TOO_MANY_PARAMETERS_RECIPIENT);
}
$this->addRecipient("cc", $address, $variables);
return end($this->message['cc']);
}
/**
* @param string $address
* @param array|null $variables
* @return mixed
* @throws TooManyParameters
*/
public function addBccRecipient($address, $variables = null)
{
if ($this->counters['recipients']['bcc'] > Api::RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(ExceptionMessages::TOO_MANY_PARAMETERS_RECIPIENT);
if ($this->counters['recipients']['bcc'] > RECIPIENT_COUNT_LIMIT) {
throw new TooManyParameters(TOO_MANY_PARAMETERS_RECIPIENT);
}
$this->addRecipient("bcc", $address, $variables);
return end($this->message['bcc']);
}
/**
* @param string $address
* @param array|null $variables
* @return mixed
*/
public function setFromAddress($address, $variables = null)
{
$this->addRecipient("from", $address, $variables);
@ -179,11 +120,6 @@ class MessageBuilder
return $this->message['from'];
}
/**
* @param string $address
* @param array|null $variables
* @return mixed
*/
public function setReplyToAddress($address, $variables = null)
{
$this->addRecipient("h:reply-to", $address, $variables);
@ -191,11 +127,7 @@ class MessageBuilder
return $this->message['h:reply-to'];
}
/**
* @param string $subject
* @return mixed
*/
public function setSubject($subject = "")
public function setSubject($subject = null)
{
if ($subject == null || $subject == "") {
$subject = " ";
@ -205,11 +137,6 @@ class MessageBuilder
return $this->message['subject'];
}
/**
* @param string $headerName
* @param mixed $headerData
* @return mixed
*/
public function addCustomHeader($headerName, $headerData)
{
if (!preg_match("/^h:/i", $headerName)) {
@ -220,10 +147,6 @@ class MessageBuilder
return $this->message[$headerName];
}
/**
* @param string $textBody
* @return string
*/
public function setTextBody($textBody)
{
if ($textBody == null || $textBody == "") {
@ -234,10 +157,6 @@ class MessageBuilder
return $this->message['text'];
}
/**
* @param string $htmlBody
* @return string
*/
public function setHtmlBody($htmlBody)
{
if ($htmlBody == null || $htmlBody == "") {
@ -248,11 +167,6 @@ class MessageBuilder
return $this->message['html'];
}
/**
* @param string $attachmentPath
* @param string|null $attachmentName
* @return bool
*/
public function addAttachment($attachmentPath, $attachmentName = null)
{
if (isset($this->files["attachment"])) {
@ -273,11 +187,6 @@ class MessageBuilder
return true;
}
/**
* @param string $inlineImagePath
* @param string|null $inlineImageName
* @throws InvalidParameter
*/
public function addInlineImage($inlineImagePath, $inlineImageName = null)
{
if (preg_match("/^@/", $inlineImagePath)) {
@ -298,14 +207,10 @@ class MessageBuilder
return true;
} else {
throw new InvalidParameter(ExceptionMessages::INVALID_PARAMETER_INLINE);
throw new InvalidParameter(INVALID_PARAMETER_INLINE);
}
}
/**
* @param boolean $testMode
* @return string
*/
public function setTestMode($testMode)
{
if (filter_var($testMode, FILTER_VALIDATE_BOOLEAN)) {
@ -318,14 +223,9 @@ class MessageBuilder
return $this->message['o:testmode'];
}
/**
* @param string|int $campaignId
* @return string|int
* @throws TooManyParameters
*/
public function addCampaignId($campaignId)
{
if ($this->counters['attributes']['campaign_id'] < Api::CAMPAIGN_ID_LIMIT) {
if ($this->counters['attributes']['campaign_id'] < CAMPAIGN_ID_LIMIT) {
if (isset($this->message['o:campaign'])) {
array_push($this->message['o:campaign'], $campaignId);
} else {
@ -335,17 +235,13 @@ class MessageBuilder
return $this->message['o:campaign'];
} else {
throw new TooManyParameters(ExceptionMessages::TOO_MANY_PARAMETERS_CAMPAIGNS);
throw new TooManyParameters(TOO_MANY_PARAMETERS_CAMPAIGNS);
}
}
/**
* @param string $tag
* @throws TooManyParameters
*/
public function addTag($tag)
{
if ($this->counters['attributes']['tag'] < Api::TAG_LIMIT) {
if ($this->counters['attributes']['tag'] < TAG_LIMIT) {
if (isset($this->message['o:tag'])) {
array_push($this->message['o:tag'], $tag);
} else {
@ -355,14 +251,10 @@ class MessageBuilder
return $this->message['o:tag'];
} else {
throw new TooManyParameters(ExceptionMessages::TOO_MANY_PARAMETERS_TAGS);
throw new TooManyParameters(TOO_MANY_PARAMETERS_TAGS);
}
}
/**
* @param boolean $enabled
* @return mixed
*/
public function setDkim($enabled)
{
if (filter_var($enabled, FILTER_VALIDATE_BOOLEAN)) {
@ -375,10 +267,6 @@ class MessageBuilder
return $this->message["o:dkim"];
}
/**
* @param boolean $enabled
* @return string
*/
public function setOpenTracking($enabled)
{
if (filter_var($enabled, FILTER_VALIDATE_BOOLEAN)) {
@ -391,10 +279,6 @@ class MessageBuilder
return $this->message['o:tracking-opens'];
}
/**
* @param boolean $enabled
* @return string
*/
public function setClickTracking($enabled)
{
if (filter_var($enabled, FILTER_VALIDATE_BOOLEAN)) {
@ -409,17 +293,12 @@ class MessageBuilder
return $this->message['o:tracking-clicks'];
}
/**
* @param string $timeDate
* @param string|null $timeZone
* @return string
*/
public function setDeliveryTime($timeDate, $timeZone = null)
{
if (isset($timeZone)) {
$timeZoneObj = new \DateTimeZone("$timeZone");
} else {
$timeZoneObj = new \DateTimeZone(Api::DEFAULT_TIME_ZONE);
$timeZoneObj = new \DateTimeZone(\DEFAULT_TIME_ZONE);
}
$dateTimeObj = new \DateTime($timeDate, $timeZoneObj);
@ -429,20 +308,11 @@ class MessageBuilder
return $this->message['o:deliverytime'];
}
/**
* @param string $customName
* @param mixed $data
*/
public function addCustomData($customName, $data)
{
$this->message['v:' . $customName] = json_encode($data);
}
/**
* @param string $parameterName
* @param mixed $data
* @return mixed
*/
public function addCustomParameter($parameterName, $data)
{
if (isset($this->message[$parameterName])) {
@ -456,25 +326,16 @@ class MessageBuilder
}
}
/**
* @param array $message
*/
public function setMessage($message)
{
$this->message = $message;
}
/**
* @return array
*/
public function getMessage()
{
return $this->message;
}
/**
* @return array
*/
public function getFiles()
{
return $this->files;

19
sites/all/libraries/mailgun/tests/Mailgun/Tests/Connection/ConnectionTest.php Normal file
View File

@ -0,0 +1,19 @@
<?PHP
namespace Mailgun\Tests\Connection;
use Mailgun\Tests\Mock\Mailgun;
class ConnectionTest extends \Mailgun\Tests\MailgunTestCase
{
private $client;
public function setUp()
{
}
public function testNewClientInstantiation()
{
$this->client = new Mailgun("My-Super-Awesome-API-Key", "samples.mailgun.org", false);
}
}

8
sites/all/libraries/mailgun/tests/Mailgun/Tests/MailgunTest.php
View File

@ -16,21 +16,21 @@ class MailgunTest extends \Mailgun\Tests\MailgunTestCase
public function testVerifyWebhookGood() {
$client = new Mailgun('key-3ax6xnjp29jd6fds4gc373sgvjxteol0');
$postData = array(
$postData = [
'timestamp' => '1403645220',
'token' => '5egbgr1vjgqxtrnp65xfznchgdccwh5d6i09vijqi3whgowmn6',
'signature' => '9cfc5c41582e51246e73c88d34db3af0a3a2692a76fbab81492842f000256d33',
);
];
assert($client->verifyWebhookSignature($postData));
}
public function testVerifyWebhookBad() {
$client = new Mailgun('key-3ax6xnjp29jd6fds4gc373sgvjxteol0');
$postData = array(
$postData = [
'timestamp' => '1403645220',
'token' => 'owyldpe6nxhmrn78epljl6bj0orrki1u3d2v5e6cnlmmuox8jr',
'signature' => '9cfc5c41582e51246e73c88d34db3af0a3a2692a76fbab81492842f000256d33',
);
];
assert(!$client->verifyWebhookSignature($postData));
}
}

4
sites/all/libraries/mailgun/tests/Mailgun/Tests/MailgunTestCase.php
View File

@ -2,6 +2,8 @@
namespace Mailgun\Tests;
abstract class MailgunTestCase extends \PHPUnit_Framework_TestCase
use Guzzle\Tests\GuzzleTestCase;
abstract class MailgunTestCase extends GuzzleTestCase
{
}

2
sites/all/libraries/mailgun/tests/Mailgun/Tests/Messages/MessageBuilderTest.php
View File

@ -9,7 +9,7 @@ class MessageBuilderTest extends \Mailgun\Tests\MailgunTestCase
public function setUp()
{
$this->client = new Mailgun();
$this->client = new Mailgun("My-Super-Awesome-API-Key", "samples.mailgun.org", false);
}
public function testBlankInstantiation()

26
sites/all/libraries/mailgun/tests/Mailgun/Tests/Mock/Connection/TestBroker.php
View File

@ -1,11 +1,7 @@
<?php
namespace Mailgun\Tests\Mock\Connection;
use Mailgun\Connection\Exceptions\GenericHTTPError;
use Mailgun\Connection\Exceptions\InvalidCredentials;
use Mailgun\Connection\Exceptions\MissingEndpoint;
use Mailgun\Connection\RestClient;
use Mailgun\Messages\Exceptions\MissingRequiredMIMEParameters;
class TestBroker extends RestClient
{
@ -13,33 +9,33 @@ class TestBroker extends RestClient
protected $apiEndpoint;
public function __construct($apiKey = null, $apiHost = "api.mailgun.net", $apiVersion = "v3")
public function __construct($apiKey = null, $apiEndpoint = "api.mailgun.net", $apiVersion = "v2")
{
$this->apiKey = $apiKey;
$this->apiEndpoint = $apiHost;
$this->apiEndpoint = $apiEndpoint;
}
public function post($endpointUrl, $postData = array(), $files = array())
{
return $this->testResponseHandler($endpointUrl, $httpResponseCode = 200);
return $this->responseHandler($endpointUrl, $httpResponseCode = 200);
}
public function get($endpointUrl, $queryString = array())
{
return $this->testResponseHandler($endpointUrl, $httpResponseCode = 200);
return $this->responseHandler($endpointUrl, $httpResponseCode = 200);
}
public function delete($endpointUrl)
{
return $this->testResponseHandler($endpointUrl, $httpResponseCode = 200);
return $this->responseHandler($endpointUrl, $httpResponseCode = 200);
}
public function put($endpointUrl, $queryString)
{
return $this->testResponseHandler($endpointUrl, $httpResponseCode = 200);
return $this->responseHandler($endpointUrl, $httpResponseCode = 200);
}
public function testResponseHandler($endpointUrl, $httpResponseCode = 200)
public function responseHandler($endpointUrl, $httpResponseCode = 200)
{
if ($httpResponseCode === 200) {
$result = new \stdClass();
@ -48,13 +44,13 @@ class TestBroker extends RestClient
foreach ($jsonResponseData as $key => $value) {
$result->http_response_body->$key = $value;
}
} elseif ($httpResponseCode == 400) {
} elseif ($httpStatusCode == 400) {
throw new MissingRequiredMIMEParameters(EXCEPTION_MISSING_REQUIRED_MIME_PARAMETERS);
} elseif ($httpResponseCode == 401) {
} elseif ($httpStatusCode == 401) {
throw new InvalidCredentials(EXCEPTION_INVALID_CREDENTIALS);
} elseif ($httpResponseCode == 401) {
} elseif ($httpStatusCode == 401) {
throw new GenericHTTPError(EXCEPTION_INVALID_CREDENTIALS);
} elseif ($httpResponseCode == 404) {
} elseif ($httpStatusCode == 404) {
throw new MissingEndpoint(EXCEPTION_MISSING_ENDPOINT);
} else {
throw new GenericHTTPError(EXCEPTION_GENERIC_HTTP_ERROR);

2
sites/all/libraries/mailgun/tests/Mailgun/Tests/Mock/Mailgun.php
View File

@ -10,7 +10,7 @@ class Mailgun extends Base
protected $debug;
protected $restClient;
public function __construct($apiKey = null, $apiEndpoint = "api.mailgun.net", $apiVersion = "v3")
public function __construct($apiKey = null, $apiEndpoint = "api.mailgun.net", $apiVersion = "v2")
{
$this->restClient = new TestBroker($apiKey, $apiEndpoint, $apiVersion);
}