/**
* This method adds the current parameter to the specified REST API request.
*
* @param \GuzzleHttp\Psr7\Request $request
* @return Request
*/
public function apply(Request $request)
{
$queryString = $request->getUri()->getQuery();
$queryParts = \GuzzleHttp\Psr7\parse_query($queryString);
$queryParts[$this->name] = $this->value;
$queryString = \GuzzleHttp\Psr7\build_query($queryParts);
return $request->withUri($request->getUri()->withQuery($queryString));
}
/**
* Processes DirectAdmin style encoded responses into a sane array.
*
* @param string $data
* @return array
*/
public static function responseToArray($data)
{
$unescaped = preg_replace_callback('/&#([0-9]{2})/', function ($val) {
return chr($val[1]);
}, $data);
return \GuzzleHttp\Psr7\parse_query($unescaped);
}
/**
* Get transport details
*
* @return array
*/
public function getTransportDetails()
{
$transportAddress = null;
$transportAddress = $this->ms->getRequest()->getHeader('X-RxWebsocket-Remote-Address')[0];
$request = $this->ms->getRequest();
$headers = $request->getHeaders();
$queryParams = \GuzzleHttp\Psr7\parse_query($request->getUri()->getQuery());
$cookies = $request->getHeader('Set-Cookie');
$url = $request->getRequestTarget();
return ["type" => "rxwebsocket", "transport_address" => $transportAddress, "headers" => $headers, "url" => $url, "query_params" => $queryParams, "cookies" => $cookies];
}
public function testSave()
{
StreamWrapper::emulate(HttpEmulation::fromCallable(function (RequestInterface $request) {
$this->assertEquals('POST', $request->getMethod());
$this->assertEquals('/1.1/statuses/update.json', $request->getUri()->getPath());
$this->assertEquals(['status' => 'Hello!'], \GuzzleHttp\Psr7\parse_query($request->getBody()->getContents()));
return new \GuzzleHttp\Psr7\Response(200, [], json_encode(['id' => 1234, 'text' => 'Hello!']));
}));
$statusesEndpoint = EndpointRegistry::get('CvoTechnologies/Twitter.Statuses');
$resource = $statusesEndpoint->newEntity(['text' => 'Hello!']);
$this->assertInstanceOf('Muffin\\Webservice\\Model\\Resource', $statusesEndpoint->save($resource));
}
/**
* Construct the object.
*
* @param string $name The domain name
* @param UserContext $context The owning user context
* @param string|array $config The basic config string as returned by CMD_API_ADDITIONAL_DOMAINS
*/
public function __construct($name, UserContext $context, $config)
{
parent::__construct($name, $context);
// Unpack domain config
$data = is_array($config) ? $config : \GuzzleHttp\Psr7\parse_query($config);
$this->domainName = $data['domain'];
// Determine owner
if ($data['username'] === $context->getUsername()) {
$this->owner = $context->getContextUser();
} else {
throw new DirectAdminException('Could not determine relationship between context user and domain');
}
// Parse plain options
$bandwidths = array_map('trim', explode('/', $data['bandwidth']));
$this->bandwidthUsed = floatval($bandwidths[0]);
$this->bandwidthLimit = ctype_alpha($bandwidths[1]) ? null : floatval($bandwidths[1]);
$this->diskUsage = floatval($data['quota']);
$this->aliases = array_filter(explode('|', $data['alias_pointers']));
$this->pointers = array_filter(explode('|', $data['pointers']));
}
protected function getHeaderViewData($title, Request $request = null)
{
$session = $this->get('session');
$header = new Header($title);
$header->stores = new Url($this->trans('header.stores'), '');
$header->help = new Url($this->trans('header.help'), '');
$header->callUs = new Url($this->trans('header.callUs', ['phone' => $this->config['sunrise.header.callUs']]), '');
$header->location = new ViewData();
$languages = new ViewDataCollection();
$routeParams = $request->get('_route_params');
$queryParams = \GuzzleHttp\Psr7\parse_query($request->getQueryString());
foreach ($this->config['languages'] as $language) {
$languageEntry = new ViewData();
if ($language == \Locale::getPrimaryLanguage($this->locale)) {
$languageEntry->selected = true;
}
$languageEntry->label = $this->trans('header.languages.' . $language);
$routeParams['_locale'] = $language;
$languageUri = $this->generateUrl($request->get('_route'), $routeParams);
$uri = new Uri($languageUri);
$languageEntry->value = (string) $uri->withQuery(\GuzzleHttp\Psr7\build_query($queryParams));
$languages->add($languageEntry);
}
$header->location->language = $languages;
// $countries = new ViewDataCollection();
// foreach ($this->config['countries'] as $country) {
// $countryEntry = new ViewData();
// $countryEntry->label = $this->trans('header.countries.' . $country);
// $countryEntry->value = $country;
// $countries->add($countryEntry);
// }
//
// $header->location->country = $countries;
$header->user = new ViewData();
$header->user->isLoggedIn = false;
$header->user->signIn = new Url('Login', '');
$header->miniCart = new ViewData();
$header->miniCart->totalItems = $session->get('cartNumItems', 0);
$header->navMenu = $this->getNavMenu();
return $header;
}
/**
* @param RequestInterface $request
*
* @return bool
*/
private function isRequestValid(RequestInterface $request)
{
$uri = $request->getUri();
$queryParams = \GuzzleHttp\Psr7\parse_query($uri->getQuery());
return $request->hasHeader('Authorization') || $request->hasHeader('Authentication') || array_key_exists('jwt', $queryParams) || !empty($queryParams['jwt']);
}
protected function getFilters(Request $request)
{
$filters = [];
$facetConfigs = $this->config->get('sunrise.products.facets');
$uri = new Uri($request->getRequestUri());
$queryParams = \GuzzleHttp\Psr7\parse_query($uri->getQuery());
$category = $this->getCategory($request);
if ($category instanceof Category) {
$filters['filter'][] = Filter::of()->setName('categories.id')->setValue($category->getId());
}
foreach ($queryParams as $filterName => $params) {
if (!isset($facetConfigs[$filterName])) {
continue;
}
$facetConfig = $facetConfigs[$filterName];
if ($facetConfig['multi']) {
if (!is_array($params)) {
$params = [$params];
}
$filter = Filter::ofType('array');
} else {
$filter = Filter::of();
}
switch ($facetConfig['type']) {
case 'text':
$filter = $filter->setName('variants.attributes.' . $facetConfig['attribute'])->setValue($params);
$filters['filter'][] = $filters['filter.facets'][] = $filter;
break;
case 'enum':
$filter = $filter->setName('variants.attributes.' . $facetConfig['attribute'] . '.key')->setValue($params);
$filters['filter'][] = $filters['filter.facets'][] = $filter;
break;
default:
throw new \InvalidArgumentException('Facet type not implemented');
}
}
return $filters;
}
public function testUpdate()
{
StreamWrapper::emulate(HttpEmulation::fromCallable(function (RequestInterface $request) {
$this->assertEquals('POST', $request->getMethod());
$this->assertEquals('/1.1/statuses/update.json', $request->getUri()->getPath());
$this->assertEquals(['id' => '2', 'status' => 'Status 2?'], \GuzzleHttp\Psr7\parse_query($request->getBody()->getContents()));
return new \GuzzleHttp\Psr7\Response(200, [], json_encode(['id' => 2, 'text' => 'Status 2?']));
}));
$query = new Query($this->webservice, new Endpoint(['endpoint' => 'statuses', 'connection' => $this->webservice->driver()]));
$query->action(Query::ACTION_UPDATE);
$query->set(['status' => 'Status 2?']);
$query->where(['id' => 2]);
$result = $this->webservice->execute($query);
$this->assertInstanceOf('Muffin\\Webservice\\Model\\Resource', $result);
$this->assertEquals(2, $result->id);
$this->assertEquals('Status 2?', $result->text);
}
/**
* Cache wrapper to keep mailbox stats up to date.
*
* @param string $key
* @return mixed
*/
protected function getData($key)
{
return $this->getCacheItem(self::CACHE_DATA, $key, function () {
$result = $this->getContext()->invokeGet('POP', ['domain' => $this->getDomainName(), 'action' => 'full_list']);
return \GuzzleHttp\Psr7\parse_query($result[$this->getPrefix()]);
});
}
/**
* Adds authentication header to the request headers.
*
* @param \GuzzleHttp\Psr7\Request $request HTTP request object.
*
* @return \GuzzleHttp\Psr7\Request
*/
public function handleRequest($request)
{
$requestHeaders = HttpFormatter::formatHeaders($request->getHeaders());
$signedKey = $this->_authenticationScheme->getAuthorizationHeader($requestHeaders, $request->getUri(), \GuzzleHttp\Psr7\parse_query($request->getUri()->getQuery()), $request->getMethod());
return $request->withHeader(Resources::AUTHENTICATION, $signedKey);
}
/**
* Calculate signature for request
*
* @param RequestInterface $request Request to generate a signature for
* @param array $params Oauth parameters.
*
* @return string
*
* @throws \RuntimeException
*/
public function getSignature(RequestInterface $request, array $params)
{
// Remove oauth_signature if present
// Ref: Spec: 9.1.1 ("The oauth_signature parameter MUST be excluded.")
unset($params['oauth_signature']);
// Add POST fields if the request uses POST fields and no files
if ($request->getHeaderLine('Content-Type') == 'application/x-www-form-urlencoded') {
$body = \GuzzleHttp\Psr7\parse_query($request->getBody()->getContents());
$params += $body;
}
// Parse & add query string parameters as base string parameters
$query = $request->getUri()->getQuery();
$params += \GuzzleHttp\Psr7\parse_query($query);
$baseString = $this->createBaseString($request, $this->prepareParameters($params));
// Implements double-dispatch to sign requests
switch ($this->config['signature_method']) {
case Oauth1::SIGNATURE_METHOD_HMAC:
$signature = $this->signUsingHmacSha1($baseString);
break;
case Oauth1::SIGNATURE_METHOD_RSA:
$signature = $this->signUsingRsaSha1($baseString);
break;
case Oauth1::SIGNATURE_METHOD_PLAINTEXT:
$signature = $this->signUsingPlaintext($baseString);
break;
default:
throw new \RuntimeException('Unknown signature method: ' . $this->config['signature_method']);
break;
}
return base64_encode($signature);
}
public function getQuery()
{
return \GuzzleHttp\Psr7\parse_query($this->query);
}
public function testGetClassifiersVerbose()
{
$container = [];
$guzzle = $this->getMockHttpClientWithHistoryAndResponses($container, [$this->getMockHttpResponse('GetClassifiersSuccess.txt')]);
$this->client = new Client($guzzle);
$this->client->initialize(['username' => $this->username, 'password' => $this->password]);
/** @var GetClassifiersRequest $request */
$classifiersRequest = $this->client->getClassifiers(['verbose' => 'true']);
/** @var ClassifiersResponse $response */
$response = $classifiersRequest->send();
$response->getClassifiers();
$transaction = $container[0];
/** @var Request $request */
$request = $transaction['request'];
/** @var Uri $uri */
$uri = $request->getUri();
// Check verbose query parameter
$query = \GuzzleHttp\Psr7\parse_query($uri->getQuery());
$this->assertArrayHasKey('verbose', $query);
}
public function export($url)
{
list($baseUrl, $query) = explode('?', $url);
/** @var Response $response */
$response = $this->api->request($baseUrl, 'GET', ['Accept' => 'text/csv; charset=UTF-8', 'GData-Version' => '3.0'], \GuzzleHttp\Psr7\parse_query($query));
return $response->getBody();
}
public function testOnlyTouchesWhenAuthConfigIsOauth()
{
$stack = HandlerStack::create();
$middleware = new Oauth1($this->config);
$stack->push($middleware);
$container = [];
$history = Middleware::history($container);
$stack->push($history);
$client = new Client(['handler' => $stack]);
$client->get('http://httpbin.org');
/* @var Request $request */
$request = $container[0]['request'];
$this->assertCount(0, \GuzzleHttp\Psr7\parse_query($request->getUri()->getQuery()));
$this->assertEmpty($request->getHeader('Authorization'));
}
