public function forwardAction()
{
$alias = $this->params('alias');
$instance = $this->getInstanceManager()->getInstanceFromRequest();
try {
$location = $this->aliasManager->findCanonicalAlias($alias, $instance);
$this->redirect()->toUrl($location);
$this->getResponse()->setStatusCode(301);
return false;
} catch (CanonicalUrlNotFoundException $e) {
}
try {
$source = $this->aliasManager->findSourceByAlias($alias);
} catch (AliasNotFoundException $e) {
$this->getResponse()->setStatusCode(404);
return false;
}
$router = $this->getServiceLocator()->get('Router');
$request = new Request();
$request->setMethod(Request::METHOD_GET);
$request->setUri($source);
$routeMatch = $router->match($request);
if ($routeMatch === null) {
$this->getResponse()->setStatusCode(404);
return false;
}
$this->getEvent()->setRouteMatch($routeMatch);
$params = $routeMatch->getParams();
$controller = $params['controller'];
$return = $this->forward()->dispatch($controller, ArrayUtils::merge($params, ['forwarded' => true]));
return $return;
}
/**
* @param $ipString
* @return IdentityInformation
* @throws \Zend\Validator\Exception\InvalidArgumentException
*/
public function getIpInfo($ipString)
{
$ipValidator = new Ip();
if (!$ipValidator->isValid($ipString)) {
throw new InvalidArgumentException();
}
// creating request object
$request = new Request();
$request->setUri($this->endPoint . $ipString . '/json');
$client = new Client();
$adapter = new Client\Adapter\Curl();
$adapter->setCurlOption(CURLOPT_TIMEOUT_MS, 500);
$client->setAdapter($adapter);
$response = $client->send($request);
$data = $response->getBody();
$dataArray = json_decode($data);
$identityInformation = new IdentityInformation();
$identityInformation->setCountry(isset($dataArray->country) ? $dataArray->country : '');
$identityInformation->setRegion(isset($dataArray->region) ? $dataArray->region : '');
$identityInformation->setCity(isset($dataArray->city) ? $dataArray->city : '');
$identityInformation->setLocation(isset($dataArray->loc) ? $dataArray->loc : '');
$identityInformation->setProvider(isset($dataArray->org) ? $dataArray->org : '');
$identityInformation->setHostName(isset($dataArray->hostname) ? $dataArray->hostname : '');
return $identityInformation;
}
/**
* Send request elasticsearch like this :
* curl -X{$httpMethod} http://host/type/index/{$elasticMethod} -d '{json_decode($content)}'
* @param int $httpMethod
* @param string $elasticMethod
* @param string $content
*
* @return Stdlib\ResponseInterface
*/
public function sendRequest($httpMethod = Request::METHOD_GET, $elasticMethod = null, $content = null)
{
$request = new Request();
$request->setUri($this->url . $elasticMethod)->setMethod($httpMethod)->setContent($content);
$client = new Client();
return $client->dispatch($request);
}
public function callServer($method, $params)
{
// Get the URI and Url Elements
$apiUrl = $this->generateUrl($method);
$requestUri = $apiUrl['uri'];
// Convert the params to something MC can understand
$params = $this->processParams($params);
$params["apikey"] = $this->getConfig('apiKey');
$request = new Request();
$request->setMethod(Request::METHOD_POST);
$request->setUri($requestUri);
$request->getHeaders()->addHeaders(array('Host' => $apiUrl['host'], 'User-Agent' => 'MCAPI/' . $this->getConfig('apiVersion'), 'Content-type' => 'application/x-www-form-urlencoded'));
$client = new Client();
$client->setRequest($request);
$client->setParameterPost($params);
$result = $client->send();
if ($result->getHeaders()->get('X-MailChimp-API-Error-Code')) {
$error = unserialize($result->getBody());
if (isset($error['error'])) {
throw new MailchimpException('The mailchimp API has returned an error (' . $error['code'] . ': ' . $error['error'] . ')');
return false;
} else {
throw new MailchimpException('There was an unspecified error');
return false;
}
}
return $result->getBody();
}
/**
* {@inheritDoc}
*/
public function createTokenResponse(Request $request, Client $client = null, TokenOwnerInterface $owner = null)
{
$token = $request->getPost('access_token');
$scope = $request->getPost('scope');
if (null === $token) {
throw OAuth2Exception::invalidRequest('Missing parameter access_token');
}
$owner = $this->getOwner($token);
if (!$owner instanceof TokenOwnerInterface) {
throw OAuth2Exception::accessDenied('Unable to load user from this token');
}
/**
* @var AccessToken $accessToken
* @var null|RefreshToken $refreshToken
* */
$accessToken = new AccessToken();
$refreshToken = null;
// Generate token
$this->populateToken($accessToken, $client, $owner, $scope);
$accessToken = $this->accessTokenService->createToken($accessToken);
// Before generating a refresh token, we must make sure the authorization server supports this grant
if ($this->authorizationServer->hasGrant(RefreshTokenGrant::GRANT_TYPE)) {
$refreshToken = new RefreshToken();
$this->populateToken($refreshToken, $client, $owner, $scope);
$refreshToken = $this->refreshTokenService->createToken($refreshToken);
}
return $this->prepareTokenResponse($accessToken, $refreshToken);
}
public function receiveRequest(HttpRequest $request)
{
/**
* Iterate over all events found in the body of the request
* and for each of these trigger an event containing the event data
*/
$eventData = json_decode($request->getContent(), true);
$manager = $this->getEventManager();
$params = ['requestBody' => $request->getContent(), 'error' => false];
/**
* Make sure that we have an array of Send Grid events
*/
if (!is_array($eventData)) {
$params['message'] = 'Invalid JSON Body, or unable to decode JSON payload';
$params['error'] = true;
$manager->trigger(self::EVENT_UNEXPECTED_FORMAT, $this, $params);
return;
}
/**
* Iterate over each Send Grid Event and trigger internal event for each
*/
foreach ($eventData as $event) {
$event['event'] = !isset($event['event']) ? null : $event['event'];
$eventName = $this->resolveEventName($event['event']);
$eventParams = $params;
if ($eventName === self::EVENT_UNEXPECTED_TYPE) {
$eventParams['error'] = true;
$eventParams['message'] = 'Unexpected Event Type';
}
$eventParams['data'] = $event;
$manager->trigger($eventName, $this, $eventParams);
}
}
/**
* @inheritdoc
*/
public function request(array $params)
{
try {
$request = new Request();
$headers = $request->getHeaders();
$request->setUri($params['url']);
$headers->addHeaderLine('Accept-Encoding', 'gzip,deflate');
if ($params['config']->isAuthenticationPossible() === true && $this->option['keys']['public'] !== null && $this->option['keys']['private'] !== null) {
/**
* Note: DATE_RFC1123 my not be RFC 1123 compliant, depending on your platform.
* @link http://www.php.net/manual/de/function.gmdate.php#25031
*/
$date = gmdate('D, d M Y H:i:s \\G\\M\\T');
$path = $request->getUri()->getPath();
$headers->addHeaderLine('Date', $date);
$headers->addHeaderLine('Authorization', $this->signRequest('GET', $date, $path));
}
if (isset($params['lastmodified'])) {
$headers->addHeaderLine('If-Modified-Since', $params['lastmodified']);
}
$response = $this->client->send($request);
$body = $response->getBody();
$headers = null;
if ($this->option['responseheader']) {
$headers = $response->getHeaders()->toArray();
$this->lastResponseHeaders = $headers;
}
} catch (\Exception $e) {
throw new ClientException('Client exception catched, use getPrevious().', 0, $e);
}
return $this->createResponse($params['config']->isJson(), $response->getStatusCode(), $body, $headers);
}
public function pharAction()
{
$client = $this->serviceLocator->get('zendServerClient');
$client = new Client();
if (defined('PHAR')) {
// the file from which the application was started is the phar file to replace
$file = $_SERVER['SCRIPT_FILENAME'];
} else {
$file = dirname($_SERVER['SCRIPT_FILENAME']) . '/zs-client.phar';
}
$request = new Request();
$request->setMethod(Request::METHOD_GET);
$request->setHeaders(Headers::fromString('If-Modified-Since: ' . gmdate('D, d M Y H:i:s T', filemtime($file))));
$request->setUri('https://github.com/zendtech/ZendServerSDK/raw/master/bin/zs-client.phar');
//$client->getAdapter()->setOptions(array('sslcapath' => __DIR__.'/../../../certs/'));
$client->setAdapter(new Curl());
$response = $client->send($request);
if ($response->getStatusCode() == 304) {
return 'Already up-to-date.';
} else {
ErrorHandler::start();
rename($file, $file . '.' . date('YmdHi') . '.backup');
$handler = fopen($file, 'w');
fwrite($handler, $response->getBody());
fclose($handler);
ErrorHandler::stop(true);
return 'The phar file was updated successfully.';
}
}
/**
* @dataProvider routeProvider
* @param Query $route
* @param string $path
* @param integer $offset
* @param array $params
*/
public function testMatching(Query $route, $path, $offset, array $params = null)
{
$request = new Request();
$request->setUri('http://example.com?' . $path);
$match = $route->match($request, $offset);
$this->assertInstanceOf('Zend\Mvc\Router\RouteMatch', $match);
}
public function process()
{
if (!$this->wizard || !$this->request->isPost()) {
return;
}
$post = $this->request->getPost();
$values = $post->getArrayCopy();
if (isset($values['previous'])) {
$this->wizard->previousStep();
return;
}
if (isset($values['cancel'])) {
return $this->doCancel();
}
$this->processCurrentStep($values);
$steps = $this->wizard->getSteps();
$currentStep = $this->wizard->getCurrentStep();
if (!$currentStep->isComplete()) {
return;
}
if ($currentStep->isComplete() && $steps->isLast($currentStep)) {
return $this->completeWizard();
}
$this->wizard->nextStep();
}
public function testOnRenderErrorCreatesAnApiProblemResponse()
{
$response = new Response();
$request = new Request();
$request->getHeaders()->addHeaderLine('Accept', 'application/json');
$event = new MvcEvent();
$event->setError(Application::ERROR_EXCEPTION);
$event->setRequest($request);
$event->setResponse($response);
$this->listener->onRenderError($event);
$this->assertTrue($event->propagationIsStopped());
$this->assertSame($response, $event->getResponse());
$this->assertEquals(406, $response->getStatusCode());
$headers = $response->getHeaders();
$this->assertTrue($headers->has('Content-Type'));
$this->assertEquals('application/problem+json', $headers->get('content-type')->getFieldValue());
$content = json_decode($response->getContent(), true);
$this->assertArrayHasKey('status', $content);
$this->assertArrayHasKey('title', $content);
$this->assertArrayHasKey('describedBy', $content);
$this->assertArrayHasKey('detail', $content);
$this->assertEquals(406, $content['status']);
$this->assertEquals('Not Acceptable', $content['title']);
$this->assertContains('www.w3.org', $content['describedBy']);
$this->assertContains('accept', $content['detail']);
}
public function matchUri($uri)
{
$request = new Request();
$request->setUri($uri);
$request->setMethod('post');
return $this->getRouter()->match($request);
}
function PlanJSONManager($action, $url, $requestjson, $uid)
{
$request = new Request();
$request->getHeaders()->addHeaders(array('Content-Type' => 'application/json; charset=UTF-8'));
//$url="";
try {
$request->setUri($url);
$request->setMethod($action);
$client = new Client();
if ($action == 'PUT' || $action == 'POST') {
$client->setUri($url);
$client->setMethod($action);
$client->setRawBody($requestjson);
$client->setEncType('application/json');
$response = $client->send();
return $response;
} else {
$response = $client->dispatch($request);
//var_dump(json_decode($response->getBody(),true));
return $response;
}
} catch (\Exception $e) {
$e->getTrace();
}
return null;
}
public function init(Request $request)
{
if (!$request->isXmlHttpRequest() || !$request->isPost()) {
$this->noAccess();
}
$this->post = $request->getPost();
}
/**
* @testdox Creates paginator via paginator service using request parameters.
* @dataProvider providePaginatorCreationData
*
*
* @param $paginatorName
* @param $params
* @param $defaultParams
* @param $usePostParams
* @param $expect
*/
public function testPaginatorCreation($paginatorName, $params, $defaultParams, $usePostParams, $expect)
{
if ($defaultParams) {
$options = array_merge($params, $defaultParams);
} else {
$options = $params;
}
$request = new Request();
if ($usePostParams) {
$request->setPost(new Parameters($params));
} else {
$request->setQuery(new Parameters($params));
}
$paginator = $this->getMockBuilder('\\Zend\\Paginator\\Paginator')->disableOriginalConstructor()->getMock();
$paginator->expects($this->once())->method('setCurrentPageNumber')->with($expect['page'])->will($this->returnSelf());
$paginator->expects($this->once())->method('setItemCountPerPage')->with($expect['count'])->will($this->returnSelf());
$paginator->expects($this->once())->method('setPageRange')->with($expect['range'])->will($this->returnSelf());
$paginators = $this->getMockBuilder('\\Core\\Paginator\\PaginatorService')->disableOriginalConstructor()->getMock();
$paginators->expects($this->once())->method('get')->with($paginatorName, $options)->willReturn($paginator);
$sm = $this->getMockBuilder('\\Zend\\ServiceManager\\ServiceManager')->disableOriginalConstructor()->getMock();
$event = $this->getMockBuilder(CreatePaginatorEvent::class)->disableOriginalConstructor()->getMock();
$em = $this->getMockBuilder(EventManager::class)->disableOriginalConstructor()->setMethods(['getEvent', 'trigger'])->getMock();
$sm->expects($this->exactly(2))->method('get')->withConsecutive(['Core/PaginatorService'], ['Core/CreatePaginator/Events'])->willReturnOnConsecutiveCalls($paginators, $em);
// check if event create paginator is triggered
$em->expects($this->once())->method('getEvent')->with(CreatePaginator::EVENT_CREATE_PAGINATOR)->willReturn($event);
$em->expects($this->once())->method('trigger')->with($event);
$controller = $this->getMockBuilder('\\Zend\\Mvc\\Controller\\AbstractActionController')->setMethods(['getServiceLocator', 'getRequest'])->getMockForAbstractClass();
$controller->expects($this->once())->method('getRequest')->willReturn($request);
$target = new CreatePaginator($sm);
$target->setController($controller);
$pager = false === $defaultParams ? $target($paginatorName, $usePostParams) : $target($paginatorName, $defaultParams, $usePostParams);
$this->assertSame($paginator, $pager);
}
/**
* Login
*
* @param \Zend\Http\Request $request
* @param \Zend\Http\Response $response
* @return null|array|\Zend\Http\Response
*/
public function login(array $options, HttpRequest $request, HttpResponse $response = null)
{
if (null === $response) {
$response = new PhpResponse();
}
$session = $this->getSessionContainer();
$code = $request->getQuery('code');
if (empty($options['redirect_uri'])) {
$options['redirect_uri'] = $request->getUri()->getScheme() . '://' . $this->getSiteInfo()->getFulldomain() . $request->getRequestUri();
}
if (empty($code)) {
$session['state'] = String::generateRandom(32);
$session['redirect_uri'] = $options['redirect_uri'];
$response->setContent('')->setStatusCode(302)->getHeaders()->clearHeaders()->addHeaderLine('Location', static::DIALOG_URI . '?' . http_build_query(array('client_id' => $options['client_id'], 'redirect_uri' => $options['redirect_uri'], 'state' => $session['state'], 'scope' => 'email')));
if ($response instanceof PhpResponse) {
$response->send();
exit;
} else {
return $response;
}
}
$state = $request->getQuery('state');
if (empty($session['state']) || $state !== $session['state']) {
return null;
}
$client = $this->getHttpClient();
$params = null;
@parse_str($client->setMethod('GET')->setUri(static::ACCESS_URI)->setParameterGet(array('client_id' => $options['client_id'], 'redirect_uri' => $session['redirect_uri'], 'client_secret' => $options['client_secret'], 'code' => $code))->send()->getBody(), $params);
unset($session['state']);
unset($session['redirect_uri']);
if (empty($params['access_token'])) {
return null;
}
return @json_decode($client->setMethod('GET')->setUri(static::API_URI)->setParameterGet(array('access_token' => $params['access_token']))->send()->getBody(), true);
}
public function testToUriStringMultiQueryOverwrite()
{
$request = new Request();
$request->setUri('http://google.ca/test.html?foo=bar');
$request->getQuery()->set('foo', 'value');
$this->assertEquals('http://google.ca/test.html?foo=value', RequestUtils::toUriString($request));
}
public function testProcessGetRequest()
{
$moduleManager = $this->getMockBuilder('Zend\ModuleManager\ModuleManager')
->disableOriginalConstructor()
->getMock();
$moduleManager->expects($this->any())
->method('getLoadedModules')
->will($this->returnValue(array('ZFTest\Apigility\Admin\Model\TestAsset\Bar' => new BarModule)));
$moduleResource = new ModuleModel($moduleManager, array(), array());
$controller = new SourceController($moduleResource);
$request = new Request();
$request->setMethod('get');
$request->getQuery()->module = 'ZFTest\Apigility\Admin\Model\TestAsset\Bar';
$request->getQuery()->class = 'ZFTest\Apigility\Admin\Model\TestAsset\Bar\Module';
$controller->setRequest($request);
$result = $controller->sourceAction();
$this->assertTrue($result->getVariable('source') != '');
$this->assertTrue($result->getVariable('file') != '');
$this->assertEquals($result->getVariable('module'), $request->getQuery()->module);
$this->assertEquals($result->getVariable('class'), $request->getQuery()->class);
}
/**
* @dataProvider uploadMethods
*/
public function testDoesNotMarkUploadFileAsInvalidForPutAndPatchHttpRequests($method)
{
$request = new HttpRequest();
$request->setMethod($method);
$this->validator->setRequest($request);
$file = ['name' => basename(__FILE__), 'tmp_name' => realpath(__FILE__), 'size' => filesize(__FILE__), 'type' => 'application/x-php', 'error' => UPLOAD_ERR_OK];
$this->assertTrue($this->validator->isValid($file), var_export($this->validator->getMessages(), 1));
}
public static function create(HttpRequest $request)
{
$queryParams = $request->getQuery()->toArray();
$postParams = $request->getPost()->toArray();
$files = $request->getFiles()->toArray();
$cookies = ($c = $request->getCookie()) ? [$c] : [];
return new OAuth2Request($queryParams, $postParams, [], $cookies, $files, $_SERVER);
}
/**
* @dataProvider routeProvider
* @param HttpMethod $route
* @param $verb
* @internal param string $path
* @internal param int $offset
* @internal param bool $shouldMatch
*/
public function testMatching(HttpMethod $route, $verb)
{
$request = new Request();
$request->setUri('http://example.com');
$request->setMethod($verb);
$match = $route->match($request);
$this->assertInstanceOf('Zend\\Mvc\\Router\\Http\\RouteMatch', $match);
}
public function testAtomAcceptHeaderSelectsFeedStrategy()
{
$request = new HttpRequest();
$request->headers()->addHeaderLine('Accept', 'application/atom+xml');
$this->event->setRequest($request);
$result = $this->strategy->selectRenderer($this->event);
$this->assertSame($this->renderer, $result);
}
/**
* @return string
*/
public function getIdentifier($paramName)
{
$tokenValue = $this->request->getQuery($paramName, false);
if ($tokenValue) {
return $tokenValue;
}
return md5(uniqid(rand(), true));
}
public function setUp()
{
$request = new Request();
$request->getQuery()->fromArray(array('all' => 'query', 'query_and_post' => 'query'));
$request->getPost()->fromArray(array('all' => 'post', 'query_and_post' => 'post', 'post_only' => 'post'));
$this->request = $request;
$this->routeMatch = new RouteMatch(array('all' => 'route'));
}
public function testNoMatchingOnDifferentScheme()
{
$request = new Request();
$request->setUri('http://example.com/');
$route = new Scheme('https');
$match = $route->match($request);
$this->assertNull($match);
}
public function testMatching()
{
$request = new Request();
$request->setUri('https://example.com/');
$route = new Scheme('https');
$match = $route->match($request);
$this->assertInstanceOf('Zend\\Mvc\\Router\\Http\\RouteMatch', $match);
}
public function testFormPluginIsNotCalledIfAjaxRequest()
{
$headers = $this->request->getHeaders();
$headers->addHeaderLine('X_REQUESTED_WITH', 'XMLHttpRequest');
$this->target->form('elements');
$result = $this->target->getResult();
$this->assertEmpty($result);
}
/**
* @param Request $request
* @return Response
*/
protected function proceed(Http $httpUri, Request $request)
{
$httpUri = $httpUri->parse($this->moduleOptions->getApiUrl() . $httpUri->toString());
$request->setUri($httpUri);
$this->httpClient->setAuth($this->moduleOptions->getUserName(), $this->moduleOptions->getPassword());
$this->httpClient->setOptions(array('sslverifypeer' => false));
return $this->httpClient->send($request);
}
/**
* @param string $method
* @param string $url
*
* @return null|string
*/
public function match($method, $url)
{
$request = new Request();
$request->setMethod($method);
$request->setUri($url);
$routeMatch = $this->router->match($request);
return $routeMatch instanceof RouteMatch ? $routeMatch->getMatchedRouteName() : null;
}
public function createAjaxRequestWithSpecificPostData($postData)
{
$request = new Request();
$request->getHeaders()->addHeaders(['X_REQUESTED_WITH' => 'XMLHttpRequest']);
$parameters = new \Zend\Stdlib\Parameters();
$parameters->fromArray($postData);
$request->setPost($parameters);
return $request;
}
