/**
* Fetch data from the Marketplace API
*
* @param $url
* @param $method
* @param null $body
* @param array $headers
* @return array|bool
*/
public function fetch($url, $method, $body = null, $headers = array())
{
if (!empty($headers)) {
$this->httpClient->setDefaultOption('headers', $headers);
}
switch ($method) {
case 'put':
case 'post':
$request = $this->httpClient->{$method}($url, $headers, $body);
break;
case 'delete':
case 'get':
$request = $this->httpClient->{$method}($url, $headers);
break;
default:
return false;
break;
}
try {
$response = $request->send();
} catch (\Exception $e) {
return false;
}
return array('status_code' => $response->getStatusCode(), 'body' => $response->json());
}
protected function _fetchById($id, $options)
{
$settings = craft()->plugins->getPlugin('weather')->getSettings();
try {
$client = new Client('http://api.openweathermap.org');
foreach ($options as $key => $value) {
$client->setDefaultOption("query/{$key}", $value);
}
if (isset($settings->apiKey) && strlen($settings->apiKey) > 0) {
$client->setDefaultOption('query/APPID', $settings->apiKey);
}
$client->setDefaultOption('query/id', $id);
$request = $client->get('/data/2.5/weather', array('$e'));
$response = $request->send();
} catch (CurlException $e) {
WeatherPlugin::log("Connection error to Open Weather Maps API", LogLevel::Error);
return false;
}
if ($response->isSuccessful()) {
$data = $response->json();
if ($data['cod'] == 200) {
return $data;
} else {
WeatherPlugin::log("Error: {$data['message']}", LogLevel::Error);
return false;
}
}
}
/**
* Constructor.
*
* @param \stdClass $credentials
* An object with the following properties:
* - username: Your Browserstack API username.
* - password: Your Browserstack API key.
*
* @throws \InvalidArgumentException
*/
function __construct($credentials)
{
if (empty($credentials->username) || empty($credentials->password)) {
throw new \InvalidArgumentException('Username and password parameters are required.');
}
$this->client = new \Guzzle\Http\Client('http://www.browserstack.com/screenshots');
$this->client->setDefaultOption('auth', array($credentials->username, $credentials->password, 'Basic'));
}
/**
* @return Client
*/
public function getHttpClient()
{
if (!$this->client instanceof Client) {
$this->client = new Client($this->uri);
$this->client->setDefaultOption('headers/Api-Key', $this->apiKey);
}
return $this->client;
}
/**
*
*/
public function __construct()
{
// init the client
$this->client = new Client();
$this->client->setDefaultOption('auth', [env('JIRA_USERNAME'), env('JIRA_PASSWORD')]);
$this->client->setDefaultOption('verify', false);
$this->parser = new JiraParser(config('jira.BaseUrl'));
}
/**
* Constructor.
*
* @param Credentials $credentials The credentials to use.
*/
public function __construct(Credentials $credentials)
{
$this->credentials = $credentials;
$this->apiUrl = self::ENDPOINT_URL;
//Initialize API Client
$this->client = new Client(self::ENDPOINT_URL);
$this->client->setDefaultOption('auth', array($this->credentials->getEmail(), $this->credentials->getAccountKey(), 'Basic'));
$this->client->setUserAgent(self::USER_AGENT);
}
/**
* @param string $apiKey
* @param string $apiEndpoint
* @param string $apiVersion
* @param bool $ssl
*/
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::API_USER, $this->apiKey));
$this->mgClient->setDefaultOption('exceptions', false);
$this->mgClient->setUserAgent(Api::SDK_USER_AGENT . '/' . Api::SDK_VERSION);
}
public function setUp()
{
parent::setUp();
$this->client = new Client($this->base_url, array('ssl.certificate_authority' => 'system'));
$this->xml_client = new Client($this->base_url, array('ssl.certificate_authority' => 'system'));
$this->client->setDefaultOption('headers/Accept', 'application/json');
$this->client->setDefaultOption('headers/Content-Type', 'application/json');
$this->xml_client->setDefaultOption('headers/Accept', 'application/xml');
$this->xml_client->setDefaultOption('headers/Content-Type', 'application/xml; charset=UTF8');
}
public function _initialize()
{
$url = trim($this->config['url'], '/') . ':' . $this->config['port'];
$this->mailcatcher = new \Guzzle\Http\Client($url);
if (isset($this->config['guzzleRequestOptions'])) {
foreach ($this->config['guzzleRequestOptions'] as $option => $value) {
$this->mailcatcher->setDefaultOption($option, $value);
}
}
}
public function client()
{
if ($this->client) {
return $this->client;
}
$this->client = new Client($this->apiUrl);
$this->client->setDefaultOption('headers/Accept', 'application/json');
$this->client->setDefaultOption('headers/Content-Type', 'application/json');
$this->authenticate();
return $this->client;
}
public function setUp() {
parent::setUp();
$this->client = new Client($this->base_url);
$this->xml_client = new Client($this->base_url);
$this->client->setDefaultOption('headers/Accept', 'application/json');
$this->client->setDefaultOption('headers/Content-Type', 'application/json');
$this->xml_client->setDefaultOption('headers/Accept', 'application/xml');
$this->xml_client->setDefaultOption('headers/Content-Type', 'application/xml; charset=UTF8');
}
/**
* @param $uri
* @param $username
* @param $password
*/
public function __construct($uri, $username = "", $password = "")
{
error_log("{$username} {$password}");
$this->uri = $uri;
$this->username = $username;
$this->password = $password;
$this->logger = new \Psr\Log\NullLogger();
$client = new Http\Client($uri);
$client->setDefaultOption('auth', array($username, $password, 'Basic'));
$client->setDefaultOption('timeout', 5);
$client->setDefaultOption('connect_timeout', 1);
$this->setClient($client);
}
/**
* Makes the request to the server.
*
* @param string $server
* @param string $service The rest service to access e.g. /connections/communities/all
* @param string $method GET, POST or PUT
* @param string $body
* @param string $headers
*/
public function makeRequest($server, $service, $method, $options, $body = null, $headers = null, $endpointName = "connections")
{
$store = SBTCredentialStore::getInstance();
$settings = new SBTSettings();
$token = $store->getToken($endpointName);
$response = null;
$client = new Client($server);
$client->setDefaultOption('verify', false);
// If global username and password is set, then use it; otherwise use user-specific credentials
if ($settings->getBasicAuthMethod($endpointName) == 'global') {
$user = $settings->getBasicAuthUsername($endpointName);
$password = $settings->getBasicAuthPassword($endpointName);
} else {
$user = $store->getBasicAuthUsername($endpointName);
$password = $store->getBasicAuthPassword($endpointName);
}
try {
$request = $client->createRequest($method, $service, $headers, $body, $options);
if ($settings->forceSSLTrust($endpointName)) {
$request->getCurlOptions()->set(CURLOPT_SSL_VERIFYHOST, false);
$request->getCurlOptions()->set(CURLOPT_SSL_VERIFYPEER, false);
}
if ($method == 'POST' && isset($_FILES['file']['tmp_name'])) {
$request->addPostFile('file', $_FILES['file']['tmp_name']);
}
$request->setAuth($user, $password);
$response = $request->send();
} catch (Guzzle\Http\Exception\BadResponseException $e) {
$response = $e->getResponse();
}
return $response;
}
public function run($data, $ips)
{
if ($data && $ips and is_array($ips)) {
foreach ($ips as $ip) {
$client = new Client('http://' . $ip);
$client->setDefaultOption('headers', ['Content-type' => 'application/json']);
$client->setDefaultOption('exceptions', false);
$client->setDefaultOption('timeout', 20);
$client->setDefaultOption('connecttimeout', 0);
$client->setDefaultOption('debug', false);
$request = $client->post("/", [], []);
$request->setBody($data);
$request->send();
}
}
}
public static function buildRequestD($pageId, $act, $servlet, $timeStamp)
{
ValidateFunc::checkNotNull($pageId, "Page id can't be null");
$client = new Client(CommonInfo::$DOMAIN . $servlet);
$params = array(CommonInfo::$URL_ACT => $act, CommonInfo::$URL_PAGEID => $pageId, CommonInfo::$URL_TIMESTAMP => $timeStamp);
$client->setDefaultOption('query', $params);
return $client;
}
/**
* Setup the guzzle client
*
* @version 1.0
* @since 1.0
* @author Daniel Noel-Davies
*
* @param string $url Api URL
*
* @return Object
*/
public static function setupClient($url)
{
// Initiate the client with the API url
$client = new Guzzle\Http\Client(Config::get('TrafficLive::api_url'));
// Setup the basic authentication to Traffic Live
$client->setDefaultOption('auth', array(Config::get('TrafficLive::api_email'), Config::get('TrafficLive::api_token'), 'Basic'));
return $client->get($url);
}
public static function addDebugOptionsToHttpClient(Client $guzzleClient)
{
$guzzleClient->setDefaultOption('debug', true);
$echoCb = function (Event $event) {
echo (string) $event['request'] . PHP_EOL;
echo (string) $event['response'] . PHP_EOL;
};
$guzzleClient->getEventDispatcher()->addListener('request.complete', $echoCb);
$guzzleClient->getEventDispatcher()->addListener('request.exception', $echoCb);
}
/** *
* @param \Guzzle\Http\Client $client
* @param JiraParser $parser
* @param string $baseUrl
* @param string $username
* @param string $password
*/
public function __construct(Client $client, JiraParser $parser, $baseUrl, $username, $password)
{
// init the client
$this->client = new Client();
$this->client->setDefaultOption('auth', array($username, $password));
$this->client->setDefaultOption('verify', false);
$this->parser = $parser;
$this->baseUrl = $baseUrl;
$this->username = $username;
$this->password = $password;
}
/**
* Register Guzzle Clients
*
* @param Application $app
*
* @return Guzzle\Http\Client
*/
public function register(Application $app)
{
$app['guzzle.client.read'] = $app->protect(function () use($app) {
$client = new GuzzleClient();
$client->setDefaultOption('auth', array($app['guzzle.client.read.user'], $app['guzzle.client.read.pass']));
return $client;
});
$app['guzzle.client.write'] = $app->protect(function () use($app) {
$client = new GuzzleClient();
$client->setDefaultOption('auth', array($app['guzzle.client.write.user'], $app['guzzle.client.write.pass']));
return $client;
});
}
/**
* @param LoggerInterface $logger
* @param Client $client
* @param UrlGeneratorInterface $router
* @param CsrfProviderInterface $csrfProvider
*/
public function __construct(LoggerInterface $logger, Client $client, Discover $discover, Import $import, UrlGeneratorInterface $router, CsrfProviderInterface $csrfProvider, $oauthClientId, $oauthClientSecret)
{
$client->setDefaultOption('headers/Accept', 'application/vnd.github.v3');
$import->setProvider($this);
$this->client = $client;
$this->discover = $discover;
$this->import = $import;
$this->csrfProvider = $csrfProvider;
$this->oauthClientId = $oauthClientId;
$this->oauthClientSecret = $oauthClientSecret;
$this->authorizeUrl = '/login/oauth/authorize';
parent::__construct($logger, $router);
}
/**
*
* @param LosConnection $losConnection
* @param \Twig_Environment $twig
* @param ContainerInterface $container
*/
public function __construct(LosConnection $losConnection, \Twig_Environment $twig, ContainerInterface $container)
{
$this->losConnection = $losConnection;
$serviceUrl = $losConnection->getServiceUrl();
if (!isset($serviceUrl)) {
$serviceUrl = $this::DEFAULT_SERVICE_URL;
}
$this->client = new Client($serviceUrl, array('ssl.certificate_authority' => false));
$this->twig = $twig;
$this->em = $container->get('doctrine')->getEntityManager();
$this->container = $container;
$this->client->setDefaultOption('auth', array($this::USERNAME, $this::PASSWORD, 'Basic'));
$this->user = array('AuthUser' => array('uri' => $losConnection->getHost(), 'username' => $losConnection->getUsername(), 'password' => $losConnection->getPassword()), 'lostype' => 0, 'apiKey' => $losConnection->getLicenseKey());
$this->logger = $this->container->get('logger');
}
/**
* The callback function for authenticating the user and then storing the token in the CredentialStore (no content
* is being requested).
*/
public function authenticationCallback()
{
if (!isset($_GET['code'])) {
return;
}
$store = SBTCredentialStore::getInstance();
$settings = new SBTSettings();
$endpointName = "connections";
if (isset($_GET['endpointName'])) {
$endpointName = $_GET['endpointName'];
}
$parameters = array('callback_uri' => $settings->getOAuth2CallbackURL($endpointName), 'code' => $_GET['code'], 'grant_type' => 'authorization_code', 'client_id' => $settings->getClientId($endpointName), 'client_secret' => $settings->getClientSecret($endpointName));
$tokenURL = $settings->getAccessTokenURL($endpointName) . '?' . http_build_query($parameters, null, '&');
$client = new Client($tokenURL);
$client->setDefaultOption('verify', false);
$headers = null;
$body = null;
$options = array();
$response = null;
try {
$request = $client->createRequest('GET', $tokenURL, $headers, $body, $options);
if ($settings->forceSSLTrust($endpointName)) {
$request->getCurlOptions()->set(CURLOPT_SSL_VERIFYHOST, false);
$request->getCurlOptions()->set(CURLOPT_SSL_VERIFYPEER, false);
}
$response = $request->send();
foreach ($response->getHeaderLines() as $h) {
if (strpos($h, "Content-Type") === 0) {
header($h, TRUE);
}
}
header(':', true, $response->getStatusCode());
header('X-PHP-Response-Code: ' . $response->getStatusCode(), true, $response->getStatusCode());
parse_str($response->getBody(TRUE), $info);
if (!isset($info['access_token'])) {
die('Missing access token. Something went wrong - make sure that your client ID and client secret are correct and try again.');
}
$accessToken = $store->getOAuthAccessToken($endpointName);
if ($accessToken == null || $accessToken == "") {
$store->storeOAuthAccessToken($info['access_token'], $endpointName);
}
header("Location: " . $settings->getOAuthOrigin($endpointName));
} catch (Guzzle\Http\Exception\BadResponseException $e) {
$response = $e->getResponse();
print_r($response->getBody(TRUE));
}
}
/**
* Get HTTP browser
*
* @param \Guzzle\Http\Client
*/
protected function getBrowser()
{
if (!$this->browser instanceof Client) {
$this->browser = new Client($this->host);
// try to set User-Agent from original request
$user_agent = self::DEFAULT_USER_AGENT;
if ($this->request) {
$user_agent = $this->request->server->get('HTTP_USER_AGENT', self::DEFAULT_USER_AGENT);
}
$this->browser->setDefaultHeaders(['User-Agent' => $user_agent]);
// configure browser client
$this->browser->setDefaultOption('timeout', $this->timeout);
if ($this->proxy_list) {
$this->browser->setDefaultOption('proxy', $this->proxy_list[array_rand($this->proxy_list)]);
}
}
return $this->browser;
}
/**
* Send a request to the API
* @param string $method HTTP request method
* @param string $url the relative URL of the desired endpoint
* @param array $queryParams optional query string parameters
* @param array $data request body data
* @return array
* @throws ApiException
*/
protected function request($method, $url, $queryParams = array(), $data = array())
{
$client = new Client(self::BASE_URL);
$client->setDefaultOption("auth", array($this->key, $this->secret, "Basic"));
$headers = array("accept" => "application/json", "content-type" => "application/json");
$request = $client->createRequest($method, $url, $headers, json_encode($data));
// Add query string parameters to the request
foreach ($queryParams as $key => $value) {
$request->getQuery()->set($key, $value);
}
try {
$response = $request->send();
$responseBody = json_decode($response->getBody(true), true);
} catch (ClientErrorResponseException $e) {
$responseBody = json_decode($e->getResponse()->getBody(true), true);
throw new ApiException($e->getResponse()->getStatusCode(), $responseBody['error']);
}
return $responseBody;
}
/**
* @param string $method HTTP method
* @param string $url
* @param string $deserializeTo
* @param array|object $body
* @param array $params querystring parameters
* @throws StripeException
* @return mixed
*/
public function request($method, $url, $deserializeTo = null, $body = null, array $params = array())
{
$baseUrl = self::BASE_URL . '/' . self::VERSION . '/';
$client = new GuzzleClient($baseUrl);
$client->setDefaultOption("auth", array($this->apiKey, '', "Basic"));
$serializer = SerializerBuilder::create()->build();
if (!is_null($body)) {
$body = json_decode($serializer->serialize($body, 'json'), true);
$body = $this->convertBooleans($body);
}
$request = $client->createRequest($method, $url, null, $body);
foreach ($params as $key => $value) {
if (is_bool($value)) {
if ($value) {
$value = 'true';
} else {
$value = 'false';
}
}
if (!is_null($value)) {
$request->getQuery()->set($key, $value);
}
}
try {
$response = $request->send();
} catch (ClientErrorResponseException $e) {
$responseBody = json_decode($e->getResponse()->getBody(true), true);
$responseBody = $responseBody['error'];
$code = array_key_exists('code', $responseBody) ? $responseBody['code'] : null;
$param = array_key_exists('param', $responseBody) ? $responseBody['param'] : null;
throw new StripeException($responseBody['message'], $e->getResponse()->getStatusCode(), $responseBody['type'], $code, $param, $e);
}
if (is_null($deserializeTo)) {
$responseBody = json_decode($response->getBody(true), true);
} else {
$responseBody = $serializer->deserialize($response->getBody(true), $deserializeTo, 'json');
}
return $responseBody;
}
public static function destroyData(Event $event)
{
$io = $event->getIO();
if (!$event->isDevMode()) {
$io->write('This script is only supported in development mode. Exiting.');
return;
}
$destroy_data = $io->askConfirmation('<options=bold>Are you sure you want to destroy all local data? [y,N]: </>', false);
if (true === $destroy_data) {
$client = new Client();
$client->setDefaultOption('exceptions', false);
$es_indices = self::DEFAULT_PROJECT_NAME . '.*';
$couch_event_db = self::DEFAULT_PROJECT_NAME . '%2Bdomain_events';
$couch_process_db = self::DEFAULT_PROJECT_NAME . '%2Bprocess_states';
$io->write('-> deleting Elasticsearch indices "' . $es_indices . '"');
$client->delete('http://localhost:9200/' . $es_indices)->send();
$io->write('-> deleting CouchDb database "' . $couch_event_db . '"');
$client->delete('http://127.0.0.1:5984/' . $couch_event_db)->send();
$io->write('-> deleting CouchDb database "' . $couch_process_db . '"');
$client->delete('http://127.0.0.1:5984/' . $couch_process_db)->send();
}
return $destroy_data;
}
* The OAUTH_TOKEN environment variable is required.
*
* Usage: php gh-release.php X.Y.Z
*/
require __DIR__ . '/../vendor/autoload.php';
use Guzzle\Http\Client;
use Guzzle\Http\Url;
use Guzzle\Stream;
$owner = 'davidtsadler';
$repo = 'ebay-sdk-trading';
$token = getenv('OAUTH_TOKEN') or die('An OAUTH_TOKEN environment variable is required');
isset($argv[1]) or die('Usage php gh-release.php X.Y.Z');
$tag = $argv[1];
assert(file_exists(__DIR__ . '/artifacts/dts-trading.zip'));
assert(file_exists(__DIR__ . '/artifacts/dts-trading.phar'));
// Grab and validate the tag annotation
chdir(dirname(__DIR__));
$message = `chag contents --tag "{$tag}"` or die('Chag could not find or parse the tag');
// Create a GitHub client.
$client = new Client('https://api.github.com/');
$client->setDefaultOption('headers/Authorization', "token {$token}");
// Create the release
$response = $client->post("repos/{$owner}/{$repo}/releases", array('Content-Type' => 'application/json'), json_encode(array('tag_name' => $tag, 'name' => "Version {$tag}", 'body' => $message, 'prerelease' => false)))->send();
// Grab the location of the new release
$url = (string) $response->getHeader('Location');
// Uploads go to uploads.github.com
$uploadUrl = Url::factory($url);
$uploadUrl->setHost('uploads.github.com');
$client->post($uploadUrl . '/assets?name=dts-trading.zip', array('Content-Type' => 'application/zip'), fopen(__DIR__ . '/artifacts/dts-trading.zip', 'r'))->send();
$client->post($uploadUrl . '/assets?name=dts-trading.phar', array('Content-Type' => 'application/phar'), fopen(__DIR__ . '/artifacts/dts-trading.phar', 'r'))->send();
echo "Release successfully published to: {$url}\n";
<?php
// Guzzle v3 — our PHP is too old to do latest version
// https://guzzle3.readthedocs.org/docs.html
require 'vendor/autoload.php';
use Guzzle\Http\Client;
// constants
define('VAULT_URL', 'https://vault.cca.edu');
define('SEARCH_API', '/api/search');
// disable SSL validation since our cert causes an error
$client = new Client(VAULT_URL, array('ssl.certificate_authority' => false));
// OAuth token for this specific app, client credentials grant from "eric1"
// that account has privileges to see all items in Syllabus Collection
$token = getenv("SYLLABI_API_TOKEN");
$client->setDefaultOption('headers/X-Authorization', 'access_token=' . $token);
// construct query string for EQUELLA search API
// parse_str parses a query string into variables inside $arr
if (isset($_SERVER['QUERY_STRING'])) {
parse_str($_SERVER['QUERY_STRING'], $options);
} else {
$options = array();
}
$options['info'] = 'metadata,basic,attachment';
// search only the Syllabus Collection (this is its UUID)
$options['collections'] = '9ec74523-e018-4e01-ab4e-be4dd06cdd68';
// translate "semester" parameter into XML where query
if (isset($options['semester'])) {
$semester = $options['semester'];
unset($options['semester']);
$options['where'] = "/xml/local/courseInfo/semester = '" . $semester . "'";
}
public function __construct(Client $client = null)
{
$this->client = $client ?: new Client();
$this->client->setDefaultOption('headers', ['accept' => self::DEFAULT_MIME_TYPE]);
$this->client->setUserAgent(self::DEFAULT_USER_AGENT);
}
/**
* @param string $token
*
* @return $this
*/
public function setToken($token)
{
$this->token = $token;
$this->client->setDefaultOption('headers/Authorization', 'Bearer ' . $this->token);
return $this;
}