getSchemeAndHttpHost() public method

If the URL was called with basic authentication, the user and the password are not added to the generated string.
public getSchemeAndHttpHost ( ) : string
return string The scheme and HTTP host
 /**
  * @param Domain $domain
  * @param Request $request
  *
  * @return array
  */
 protected function buildSitemapLinks(Domain $domain, Request $request)
 {
     $links = [];
     if (!$domain->hasYearSpecificDomain()) {
         $links[$request->getSchemeAndHttpHost()] = $request->getSchemeAndHttpHost();
     }
     if ($domain->hasYearSpecificDomain()) {
         foreach ($this->months as $key => $value) {
             $links["{$request->getSchemeAndHttpHost()}/{$key}"] = "{$request->getSchemeAndHttpHost()}/{$key}";
         }
     }
     return $links;
 }
Example #2
0
 public function getRefererPath(Request $request = null)
 {
     $referer = $request->headers->get('referer');
     $baseUrl = $request->getSchemeAndHttpHost();
     $lastPath = substr($referer, strpos($referer, $baseUrl) + strlen($baseUrl));
     return $lastPath;
 }
 /**
  * @param Request $request
  *
  * @return JsonResponse
  */
 public function createAction($content, Request $request)
 {
     $rawPayment = ArrayObject::ensureArrayObject($content);
     $form = $this->formFactory->create('create_payment');
     $form->submit((array) $rawPayment);
     if (false == $form->isValid()) {
         return new JsonResponse($this->formToJsonConverter->convertInvalid($form), 400);
     }
     /** @var Payment $payment */
     $payment = $form->getData();
     $payment->setAfterUrl($payment->getAfterUrl() ?: $request->getSchemeAndHttpHost());
     $payment->setNumber($payment->getNumber() ?: date('Ymd-' . mt_rand(10000, 99999)));
     $payment->setDetails([]);
     $storage = $this->registry->getStorage($payment);
     $storage->update($payment);
     $token = $this->tokenFactory->createToken($payment->getGatewayName(), $payment, 'payment_get');
     $payment->setPublicId($token->getHash());
     $payment->addLink('self', $token->getTargetUrl());
     $payment->addLink('update', $token->getTargetUrl());
     $payment->addLink('delete', $token->getTargetUrl());
     $token = $this->tokenFactory->createAuthorizeToken($payment->getGatewayName(), $payment, $payment->getAfterUrl(), ['payum_token' => null]);
     $payment->addLink('authorize', $token->getTargetUrl());
     $token = $this->tokenFactory->createCaptureToken($payment->getGatewayName(), $payment, $payment->getAfterUrl(), ['payum_token' => null]);
     $payment->addLink('capture', $token->getTargetUrl());
     $token = $this->tokenFactory->createNotifyToken($payment->getGatewayName(), $payment);
     $payment->addLink('notify', $token->getTargetUrl());
     $storage->update($payment);
     return new JsonResponse(array('payment' => $this->paymentToJsonConverter->convert($payment)), 201, array('Location' => $payment->getLink('self')));
 }
Example #4
0
 /**
  * @param FormBuilderInterface $builder
  * @param array                $options
  */
 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     $currencies = Intl::getCurrencyBundle()->getCurrencyNames();
     if (extension_loaded('intl')) {
         $builder->add('locale', 'select2', array('choices' => Intl::getLocaleBundle()->getLocaleNames(), 'constraints' => new Constraints\NotBlank(array('message' => 'Please select a locale')), 'placeholder' => '', 'choices_as_values' => false));
     } else {
         $builder->add('locale', null, array('data' => 'en', 'read_only' => true, 'help' => 'The only currently supported locale is "en". To choose a different locale, please install the \'intl\' extension'));
     }
     $builder->add('currency', 'select2', array('choices' => $currencies, 'constraints' => new Constraints\NotBlank(array('message' => 'Please select a currency')), 'placeholder' => '', 'choices_as_values' => false));
     $builder->add('base_url', null, array('constraints' => new Constraints\NotBlank(array('message' => 'Please set the application base url')), 'data' => $this->request->getSchemeAndHttpHost() . $this->request->getBaseUrl()));
     if (0 === $this->userCount) {
         $builder->add('username', null, array('constraints' => new Constraints\NotBlank(array('message' => 'Please enter a username'))));
         $builder->add('email_address', 'email', array('constraints' => array(new Constraints\NotBlank(array('message' => 'Please enter a email')), new Constraints\Email())));
         $builder->add('password', 'repeated', array('type' => 'password', 'invalid_message' => 'The password fields must match.', 'options' => array('attr' => array('class' => 'password-field')), 'required' => true, 'first_options' => array('label' => 'Password'), 'second_options' => array('label' => 'Repeat Password'), 'constraints' => array(new Constraints\NotBlank(array('message' => 'You must enter a secure password')), new Constraints\Length(array('min' => 6)))));
     }
 }
 /**
  * @Route("/first-run" ,name="self-advert-first-run")
  */
 public function firstRunAction(Request $request)
 {
     $em = $this->getDoctrine()->getManager();
     $url = "http://freegeoip.net/json/";
     $ch = curl_init();
     curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
     curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
     curl_setopt($ch, CURLOPT_URL, $url);
     $result = curl_exec($ch);
     $data = json_decode($result, true);
     $selfAdvert = new SelfAdvert();
     if (!empty($data) || !$data) {
         $selfAdvert->setIp($data["ip"]);
         $selfAdvert->setLocation($data["city"]);
         $selfAdvert->setZipCode($data["zip_code"]);
         $ret = true;
     } else {
         $selfAdvert->setIp($_SERVER['REMOTE_ADDR']);
         $ret = false;
     }
     $selfAdvert->setHost($request->getSchemeAndHttpHost());
     $selfAdvert->setCreated(new \DateTime());
     $em->persist($selfAdvert);
     $em->flush();
     return $this->redirect('/');
 }
 public function switchLocaleAction(Request $request)
 {
     $this->guard->userIsLoggedIn();
     $this->logger->notice('User requested to switch locale');
     $returnUrl = $request->query->get('return-url');
     // Return URLs generated by us always include a path (ie. at least a forward slash)
     // @see https://github.com/symfony/symfony/blob/master/src/Symfony/Component/HttpFoundation/Request.php#L878
     $domain = $request->getSchemeAndHttpHost() . '/';
     if (strpos($returnUrl, $domain) !== 0) {
         $this->logger->error(sprintf('Illegal return-url ("%s") for redirection after changing locale, aborting request', $returnUrl));
         throw new BadRequestHttpException('Invalid return-url given');
     }
     $command = new ChangeLocaleCommand();
     $form = $this->formFactory->create('profile_switch_locale', $command, [])->handleRequest($request);
     $this->logger->notice(sprintf('Switching locale from "%s" to "%s"', $request->getLocale(), $command->newLocale));
     if ($form->isValid()) {
         $this->userService->changeLocale($command);
         $this->flashBag->add('success', 'profile.locale.locale_change_success');
         $this->logger->notice(sprintf('Successfully switched locale from "%s" to "%s"', $request->getLocale(), $command->newLocale));
     } else {
         $this->flashBag->add('error', 'profile.locale.locale_change_fail');
         $this->logger->error('Locale not switched: the switch locale form contained invalid data');
     }
     return new RedirectResponse($returnUrl);
 }
 public function switchLocaleAction(Request $request)
 {
     $returnUrl = $request->query->get('return-url');
     $domain = $request->getSchemeAndHttpHost();
     if (strpos($returnUrl, $domain) !== 0) {
         $this->get('logger')->error(sprintf('Identity "%s" used illegal return-url for redirection after changing locale, aborting request', $this->getIdentity()->id));
         throw new BadRequestHttpException('Invalid return-url given');
     }
     /** @var LoggerInterface $logger */
     $logger = $this->get('logger');
     $logger->info('Switching locale...');
     $identity = $this->getIdentity();
     if (!$identity) {
         throw new AccessDeniedHttpException('Cannot switch locales when not authenticated');
     }
     $command = new SwitchLocaleCommand();
     $command->identityId = $identity->id;
     $form = $this->createForm('stepup_switch_locale', $command, ['route' => 'ra_switch_locale', 'route_parameters' => ['return_url' => $returnUrl]]);
     $form->handleRequest($request);
     if (!$form->isValid()) {
         $this->addFlash('error', $this->get('translator')->trans('ra.flash.invalid_switch_locale_form'));
         $logger->error('The switch locale form unexpectedly contained invalid data');
         return $this->redirect($returnUrl);
     }
     $service = $this->get('ra.service.identity');
     if (!$service->switchLocale($command)) {
         $this->addFlash('error', $this->get('translator')->trans('ra.flash.error_while_switching_locale'));
         $logger->error('An error occurred while switching locales');
         return $this->redirect($returnUrl);
     }
     $logger->info('Successfully switched locale');
     return $this->redirect($returnUrl);
 }
 /**
  * Logs the duration of a specific request through the application
  *
  * @param Request $request
  * @param Response $response
  * @param double $startTime
  */
 protected static function logDuration(Request $request, Response $response, $startTime)
 {
     $duration = microtime(true) - $startTime;
     $metric = self::prefix('request_time');
     $tags = ["url" => $request->getSchemeAndHttpHost() . $request->getRequestUri(), "status_code" => $response->getStatusCode()];
     Datadog::timing($metric, $duration, 1, $tags);
 }
Example #9
0
 public function indexAction(Request $request)
 {
     $configuration = [];
     $authenticationType = $this->container->getParameter('ilios_authentication.type');
     $configuration['type'] = $authenticationType;
     if ($authenticationType == 'shibboleth') {
         $loginPath = $this->container->getParameter('ilios_authentication.shibboleth.login_path');
         $url = $request->getSchemeAndHttpHost();
         $configuration['loginUrl'] = $url . $loginPath;
     }
     if ($authenticationType === 'cas') {
         $cas = $this->container->get('ilios_authentication.cas.manager');
         $configuration['casLoginUrl'] = $cas->getLoginUrl();
     }
     $configuration['locale'] = $this->container->getParameter('locale');
     $ldapUrl = $this->container->getParameter('ilios_core.ldap.url');
     if (!empty($ldapUrl)) {
         $configuration['userSearchType'] = 'ldap';
     } else {
         $configuration['userSearchType'] = 'local';
     }
     $configuration['maxUploadSize'] = UploadedFile::getMaxFilesize();
     $configuration['apiVersion'] = WebIndexFromJson::API_VERSION;
     $configuration['trackingEnabled'] = $this->container->getParameter('ilios_core.enable_tracking');
     if ($configuration['trackingEnabled']) {
         $configuration['trackingCode'] = $this->container->getParameter('ilios_core.tracking_code');
     }
     return new JsonResponse(array('config' => $configuration));
 }
 /**
  * @param Request $request
  * @param string $code
  *
  * @return Response
  */
 public function switchAction(Request $request, $code)
 {
     if (!in_array($code, $this->currencyProvider->getAvailableCurrenciesCodes())) {
         throw new HttpException(Response::HTTP_NOT_ACCEPTABLE, sprintf('The currency code "%s" is invalid.', $code));
     }
     $this->currencyChangeHandler->handle($code);
     return new RedirectResponse($request->headers->get('referer', $request->getSchemeAndHttpHost()));
 }
 /**
  * @param Request $request
  * @return array
  */
 private function prepareOptions(Request $request)
 {
     $options = array(CURLOPT_POST => 1, CURLOPT_HEADER => 0, CURLOPT_URL => $request->getSchemeAndHttpHost() . $request->getRequestUri(), CURLOPT_FRESH_CONNECT => 1, CURLOPT_RETURNTRANSFER => 1, CURLOPT_FORBID_REUSE => 1, CURLOPT_TIMEOUT => 20, CURLOPT_POSTFIELDS => $request->getContent(), CURLOPT_SSL_VERIFYHOST => false, CURLOPT_SSL_VERIFYPEER => false, CURLOPT_CUSTOMREQUEST => "POST", CURLOPT_HTTPHEADER => array('Content-Type: ' . $request->getContentType(), 'Content-Length: ' . strlen($request->getContent())));
     foreach ($this->options as $key => $value) {
         $options[$key] = $value;
     }
     return $options;
 }
Example #12
0
 /**
  * Provide the install.html file.
  *
  * @param Request $request The request to process.
  *
  * @return Response
  */
 public function installAction(Request $request)
 {
     // Special case, already setup. Redirect to index then.
     if ($this->isInstalled()) {
         return new RedirectResponse($request->getUri() . 'index.html');
     }
     return new Response(str_replace('var TENSIDEApi=window.location.href.split(\'#\')[0];', 'var TENSIDEApi=\'' . $request->getSchemeAndHttpHost() . $request->getBaseUrl() . '/\';', file_get_contents($this->getAssetsDir() . '/install.html')), 200, ['Content-Type' => 'text/html; charset=UTF-8']);
 }
 /**
  * Gets the encoded URL that is passed to SnapSearch so that SnapSearch can scrape the encoded URL.
  * If _escaped_fragment_ query parameter is used, this is converted back to a hash fragment URL.
  * 
  * @return string URL intended for SnapSearch
  */
 public function get_encoded_url()
 {
     if ($this->request->query->has('_escaped_fragment_')) {
         $qs_and_hash = $this->get_real_qs_and_hash_fragment(true);
         //the query string must be ahead of the hash, because anything after hash is never passed to the server
         //and the server may require the query strings
         $url = $this->request->getSchemeAndHttpHost() . $this->request->getBaseUrl() . $this->request->getPathInfo() . $qs_and_hash['qs'] . $qs_and_hash['hash'];
         return $url;
     } else {
         //gets the rawurlencoded complete uri
         return $this->request->getUri();
     }
 }
 /**
  * Creates a previous page link if avialiable.
  * @param \Symfony\Component\HttpFoundation\Request $request
  * @param int $offset
  * @param int $limit
  * @param int $total
  * @return \Symfony\Component\HttpFoundation\Request mixed
  */
 protected function createNextLink(Request $request, $offset, $limit, $total)
 {
     $nextLink = null;
     $baseUri = $request->getSchemeAndHttpHost() . $request->getBaseUrl() . $request->getPathInfo();
     if ($offset + $limit < $total) {
         parse_str($request->getQueryString(), $qsArray);
         $qsArray['limit'] = $limit;
         $qsArray['offset'] = $limit + $offset;
         $qs = Request::normalizeQueryString(http_build_query($qsArray));
         $nextLink = $baseUri . '?' . $qs;
     }
     return $nextLink;
 }
Example #15
0
 protected function validateRequest(Request $request)
 {
     // is the Request safe?
     if (!$request->isMethodSafe()) {
         throw new AccessDeniedHttpException();
     }
     // is the Request signed?
     // we cannot use $request->getUri() here as we want to work with the original URI (no query string reordering)
     if ($this->signer->check($request->getSchemeAndHttpHost() . $request->getBaseUrl() . $request->getPathInfo() . (null !== ($qs = $request->server->get('QUERY_STRING')) ? '?' . $qs : ''))) {
         return;
     }
     throw new AccessDeniedHttpException();
 }
Example #16
0
 /**
  * View post
  *
  * @param Request $request
  * @param string  $slug
  *
  * @return array
  *
  * @throws NotFoundHttpException
  *
  * @Route("/blog/post/{slug}", name="blog_post_view")
  * @Template()
  */
 public function viewAction(Request $request, $slug)
 {
     /** @var Post $post */
     $post = $this->get('doctrine')->getManager()->getRepository("StfalconBlogBundle:Post")->findPostBySlugInLocale($slug, $request->getLocale());
     if (!$post) {
         return $this->redirect($this->generateUrl('blog'));
     }
     $seo = $this->get('sonata.seo.page');
     $seo->addMeta('name', 'description', $post->getMetaDescription())->addMeta('name', 'keywords', $post->getMetaKeywords())->addMeta('property', 'og:title', $post->getMetaTitle())->addMeta('property', 'og:url', $this->generateUrl('blog_post_view', ['slug' => $post->getSlug()], true))->addMeta('property', 'og:type', 'blog')->addMeta('property', 'og:description', $post->getMetaDescription());
     if ($post->getImage()) {
         $seo->addMeta('property', 'og:image', $request->getSchemeAndHttpHost() . $post->getImage());
     }
     return $this->_getRequestArrayWithDisqusShortname(array('post' => $post));
 }
 /**
  * Get current or a new url merged with provided parameters.
  *
  * @param string $relativeUrl
  * @param array  $parameters
  * @return string
  */
 protected function getUrl($relativeUrl = null, array $parameters = [])
 {
     // Make an absolute url of a new one url, or use the current one if none is provided
     if ($relativeUrl !== null) {
         $url = $this->request->getSchemeAndHttpHost() . $relativeUrl;
     } else {
         $url = $this->request->getSchemeAndHttpHost() . $this->request->getRequestUri();
     }
     if ($parameters) {
         $mergedParameters = array_merge($this->get(), $parameters);
         $url = (string) (new Url($url))->addQueryParameters($mergedParameters);
     }
     return $url;
 }
 /**
  * Converts all root-relative URLs to absolute URLs in RSS markup.
  *
  * Does not change any existing protocol-relative or absolute URLs.
  *
  * @param string $rss_markup
  *   The RSS markup to update.
  * @param \Symfony\Component\HttpFoundation\Request $request
  *   The current request.
  *
  * @return string
  *   The updated RSS markup.
  */
 protected function transformRootRelativeUrlsToAbsolute($rss_markup, Request $request)
 {
     $rss_dom = new \DOMDocument();
     $rss_dom->loadXML($rss_markup);
     // Invoke Html::transformRootRelativeUrlsToAbsolute() on all HTML content
     // embedded in this RSS feed.
     foreach ($rss_dom->getElementsByTagName('description') as $node) {
         $html_markup = $node->nodeValue;
         if (!empty($html_markup)) {
             $node->nodeValue = Html::transformRootRelativeUrlsToAbsolute($html_markup, $request->getSchemeAndHttpHost());
         }
     }
     return $rss_dom->saveXML();
 }
 /**
  * @param Request $request
  * @param int     $mediaId
  *
  * @Route("/delete/{mediaId}", requirements={"mediaId" = "\d+"}, name="KunstmaanMediaBundle_media_delete")
  *
  * @return RedirectResponse
  */
 public function deleteAction(Request $request, $mediaId)
 {
     $em = $this->getDoctrine()->getManager();
     /* @var Media $media */
     $media = $em->getRepository('KunstmaanMediaBundle:Media')->getMedia($mediaId);
     $medianame = $media->getName();
     $folder = $media->getFolder();
     $em->getRepository('KunstmaanMediaBundle:Media')->delete($media);
     $this->get('session')->getFlashBag()->add(FlashTypes::SUCCESS, $this->get('translator')->trans('kuma_admin.media.flash.deleted_success.%medianame%', ['%medianame%' => $medianame]));
     // If the redirect url is passed via the url we use it
     $redirectUrl = $request->query->get('redirectUrl');
     if (empty($redirectUrl) || strpos($redirectUrl, $request->getSchemeAndHttpHost()) !== 0 && strpos($redirectUrl, '/') !== 0) {
         $redirectUrl = $this->generateUrl('KunstmaanMediaBundle_folder_show', array('folderId' => $folder->getId()));
     }
     return new RedirectResponse($redirectUrl);
 }
 /**
  * @param Request $request
  * @param int     $mediaId
  *
  * @Route("/delete/{mediaId}", requirements={"mediaId" = "\d+"}, name="KunstmaanMediaBundle_media_delete")
  *
  * @return RedirectResponse
  */
 public function deleteAction(Request $request, $mediaId)
 {
     $em = $this->getDoctrine()->getManager();
     /* @var Media $media */
     $media = $em->getRepository('KunstmaanMediaBundle:Media')->getMedia($mediaId);
     $medianame = $media->getName();
     $folder = $media->getFolder();
     $em->getRepository('KunstmaanMediaBundle:Media')->delete($media);
     $this->get('session')->getFlashBag()->add('success', 'Entry \'' . $medianame . '\' has been deleted!');
     // If the redirect url is passed via the url we use it
     $redirectUrl = $request->query->get('redirectUrl');
     if (empty($redirectUrl) || strpos($redirectUrl, $request->getSchemeAndHttpHost()) !== 0 && strpos($redirectUrl, '/') !== 0) {
         $redirectUrl = $this->generateUrl('KunstmaanMediaBundle_folder_show', array('folderId' => $folder->getId()));
     }
     return new RedirectResponse($redirectUrl);
 }
Example #21
0
 protected function prepareResponse(Response $response, Request $request)
 {
     $domains = array_merge(array($this->configuration->getBackend()), $this->configuration->getAliases());
     $response->setContent(str_ireplace(array_map(function ($value) use($request) {
         return $request->getScheme() . '://' . $value;
     }, $domains), $request->getSchemeAndHttpHost(), $response->getContent()));
     if ($response->headers->has('set-cookie')) {
         $response->headers->set('set-cookie', implode(';', array_map(function ($item) use($domains, $request) {
             if (strpos($item, 'domain') !== false) {
                 return str_replace($domains, $request->getHost(), $item);
             }
             return $item;
         }, explode(';', $response->headers->get('set-cookie')))));
     }
     return $response;
 }
Example #22
0
 /**
  * @Extra\Route("/update/body/{id}", name="weaving_the_web_dashboard_debug_update_body")
  * @Extra\Template("WeavingTheWebDashboardBundle:Mail:Debug/update_body.html.twig")
  */
 public function updateBodyAction(Message $message, Request $request)
 {
     /** @var \WeavingTheWeb\Bundle\MailBundle\Storage\GmailAwareImap $storage */
     $storage = $this->get('weaving_the_web_mail.storage.imap');
     $body = $storage->fetchBodyByUid($message->getHeader()->getImapUid());
     $message->setHtmlBody($body);
     /** @var \WeavingTheWeb\Bundle\MailBundle\Parser\EmailParser $emailParser */
     $emailParser = $this->get('weaving_the_web_mail.parser.email');
     $emailParser->encodeMessageHTMLBody($message);
     $entityManager = $this->getDoctrine()->getManager();
     $entityManager->persist($message);
     $entityManager->flush();
     if ($request->query->get('referrer')) {
         $requestUri = urldecode($request->query->get('referrer'));
         return new RedirectResponse($request->getSchemeAndHttpHost() . $requestUri);
     }
     return ['message_id' => $message->getId()];
 }
Example #23
0
    private function sendEmailToAdmin(Request $request, $admin)
    {
        $url = $request->getSchemeAndHttpHost() . $request->getBasePath();
        $body = <<<EOF
<html>
<head></head>
<body>
<h1>Hi {$admin['uname']}!</h1>
<p>Zikula has been successfully installed at <a href="{$url}">{$url}</a>. If you have further questions,
visit <a href="http://zikula.org">zikula.org</a></p>
</body>
EOF;
        $message = \Swift_Message::newInstance()->setSubject(__('Zikula installation completed!'))->setFrom(\System::getVar('adminmail'))->setTo($admin['email'])->setBody($body)->setContentType('text/html');
        /**
         * @var Swift_Mailer $mailer
         */
        $mailer = $this->container->get('mailer');
        return $mailer->send($message);
    }
 /**
  * @Route("/oauth", name="oauth")
  */
 public function oauthAction(Request $request)
 {
     $client_test_token = $this->getParameter('oauth.test_token');
     if ($client_test_token != NULL) {
         $this->get('logger')->info("Authenticating with test token");
         $session = $request->getSession();
         $session->set('oauth_token', $client_test_token);
         return $this->redirectToRoute('homepage');
     }
     $client_id = $this->getParameter('oauth.client_id');
     $client_secret = $this->getParameter('oauth.client_secret');
     $base_url = $this->getParameter('oauth.base_url');
     $send_url = $base_url . '/oauth/authorize';
     $client = new Client($client_id, $client_secret);
     $redirectUrl = $request->getSchemeAndHttpHost() . $this->get('router')->generate('oauth_callback');
     $authUrl = $client->getAuthenticationUrl($send_url, $redirectUrl);
     $this->get('logger')->info("Redirecting to {$authUrl}");
     return new RedirectResponse($authUrl);
 }
Example #25
0
 protected function validateRequest(Request $request)
 {
     // is the Request safe?
     if (!$request->isMethodSafe()) {
         throw new AccessDeniedHttpException();
     }
     // does the Request come from a trusted IP?
     $trustedIps = array_merge($this->getLocalIpAddresses(), $request->getTrustedProxies());
     $remoteAddress = $request->server->get('REMOTE_ADDR');
     if (IpUtils::checkIp($remoteAddress, $trustedIps)) {
         return;
     }
     // is the Request signed?
     // we cannot use $request->getUri() here as we want to work with the original URI (no query string reordering)
     if ($this->signer->check($request->getSchemeAndHttpHost() . $request->getBaseUrl() . $request->getPathInfo() . (null !== ($qs = $request->server->get('QUERY_STRING')) ? '?' . $qs : ''))) {
         return;
     }
     throw new AccessDeniedHttpException();
 }
Example #26
0
 /**
  * @return \Symfony\Component\HttpFoundation\Response
  * @throws \Symfony\Component\Security\Core\Exception\AccessDeniedException
  *
  * @Extra\Route("/callback", name="weaving_the_web_api_oauth_callback")
  */
 public function callbackAction(Request $request)
 {
     /** @var \WeavingTheWeb\Bundle\DashboardBundle\Repository\OAuth\ClientRepository $clientRepository */
     $clientRepository = $this->container->get('weaving_the_web_dashboard.repository.oauth.client');
     /** @var \WeavingTheWeb\Bundle\DashboardBundle\Entity\OAuth\Client $client */
     $client = $clientRepository->findOneBy(['selected' => true]);
     $logger = $this->get('logger');
     if (is_null($client)) {
         $clientId = $this->container->getParameter('api_client_id');
         $clientSecret = $this->container->getParameter('api_client_secret');
         $logger->info(sprintf('Fallback on application-wise OAuth client (client id: "%s")', $clientId));
     } else {
         $clientId = $client->getClientId();
         $clientSecret = $client->getClientSecret();
     }
     /** @var \Symfony\Component\Routing\Router $router */
     $router = $this->get('router');
     $redirectUri = $request->getSchemeAndHttpHost() . $this->generateUrl('weaving_the_web_api_oauth_callback');
     $tokenUrl = $router->generate('fos_oauth_server_token', ['client_id' => $clientId, 'client_secret' => $clientSecret, 'code' => $request->query->get('code'), 'grant_type' => 'authorization_code', 'redirect_uri' => $redirectUri]);
     return new RedirectResponse($tokenUrl);
 }
 /**
  * @param Request $request
  *
  * @return null|RedirectResponse
  */
 public function findRedirect(Request $request)
 {
     $path = str_replace($request->getBaseUrl(), '/', $request->getRequestUri());
     $url = $request->getSchemeAndHttpHost() . $request->getRequestUri();
     // find possible candidates for redirection
     /** @var MapRepository $repo */
     $repo = $this->entityManager->getRepository('AstinaRedirectManagerBundle:Map');
     $maps = $repo->findCandidatesForUrlOrPath($url, $path);
     if (empty($maps)) {
         return null;
     }
     $redirect = $this->resolveRedirect($request, $maps);
     if (null === $redirect) {
         return null;
     }
     $redirectUrl = $redirect->getRedirectUrl();
     $map = $redirect->getMap();
     if ($map->isCountRedirects()) {
         $map->increaseCount();
         $this->entityManager->persist($map);
         $this->entityManager->flush($map);
     }
     return new RedirectResponse($redirectUrl, $map->getRedirectHttpCode());
 }
Example #28
0
 /**
  * @covers Symfony\Component\HttpFoundation\Request::getSchemeAndHttpHost
  */
 public function testGetSchemeAndHttpHost()
 {
     $request = new Request();
     $server = array();
     $server['SERVER_NAME'] = 'servername';
     $server['SERVER_PORT'] = '90';
     $request->initialize(array(), array(), array(), array(), array(), $server);
     $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
     $server['PHP_AUTH_USER'] = '******';
     $request->initialize(array(), array(), array(), array(), array(), $server);
     $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
     $server['PHP_AUTH_USER'] = '******';
     $request->initialize(array(), array(), array(), array(), array(), $server);
     $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
     $server['PHP_AUTH_PW'] = '0';
     $request->initialize(array(), array(), array(), array(), array(), $server);
     $this->assertEquals('http://servername:90', $request->getSchemeAndHttpHost());
 }
 public function get(Request $request)
 {
     $modelClassName = $this->modelClassName;
     $query = $modelClassName::getModelQuery();
     $limit = null;
     $page = null;
     $sort = null;
     // variables to build our links later on
     $jsonapi = new JsonApiRootNode();
     // We start by adding the link to this request
     $baseUrl = $request->getSchemeAndHttpHost() . $request->getPathInfo();
     // this might not work with a different port than 80, check later
     // Get requests can either be a list of models, or an individual model, so we must check the slug
     if (empty($this->slug)) {
         // when we don't have a slug, we are expected to always return an array response,
         // even when the result is a single object
         $jsonapi->asArray(true);
         // when the slug is empty, we must check for extra variables
         if ($request->query->has('limit') && is_numeric($request->query->get('limit'))) {
             $limit = $request->query->get('limit');
         }
         // Additional check for the page variable, we potentially need to adjust the query start
         if ($request->query->has('page') && is_numeric($request->query->get('page'))) {
             $page = $request->query->get('page');
             if (!empty($limit)) {
                 $start = ($page - 1) * $limit;
                 $query->setRange($start, $limit);
             } else {
                 $start = ($page - 1) * $this->maxLimit;
                 $query->setRange($start, $this->maxLimit);
             }
         } else {
             // no page, we can just set a limit
             if (empty($limit)) {
                 // no limit, lets set the default one
                 $query->setLimit($this->maxLimit);
             } else {
                 $query->setLimit($limit);
             }
         }
         // Lets get the pretty to regular field mapping for use in either sort or filter
         $prettyToFieldsMap = $modelClassName::getPrettyFieldsToFieldsMapping();
         // Lets also check for an order
         if ($request->query->has('sort')) {
             // sort params are split by ',' so lets evaluate them individually
             $sort = $request->query->get('sort');
             $sortQueryFields = explode(',', $sort);
             foreach ($sortQueryFields as $sortQueryField) {
                 // the json-api spec tells us, that all fields are sorted ascending, unless the field is prepended by a '-'
                 // http://jsonapi.org/format/#fetching-sorting
                 $direction = !empty($sortQueryField) && $sortQueryField[0] === '-' ? 'DESC' : 'ASC';
                 $prettyField = ltrim($sortQueryField, '-');
                 // lets remove the '-' from the start of the field if it exists
                 $prettyFieldParts = explode('.', $prettyField);
                 // if the pretty field exists, lets add it to the sort order
                 if (array_key_exists($prettyFieldParts[0], $prettyToFieldsMap)) {
                     $field = $prettyToFieldsMap[$prettyFieldParts[0]];
                     if (sizeof($prettyFieldParts) > 1) {
                         $typePrettyToFieldsMap = $modelClassName::getTypePrettyFieldToFieldsMapping();
                         // meaning we have a extra column present
                         $fieldDefinition = $modelClassName::getFieldDefinition($field);
                         $fieldType = $fieldDefinition->getType();
                         if (array_key_exists($fieldType, $typePrettyToFieldsMap) && array_key_exists($prettyFieldParts[1], $typePrettyToFieldsMap[$fieldType])) {
                             $column = $typePrettyToFieldsMap[$fieldType][$prettyFieldParts[1]];
                             $query->addSortOrder($field . '.' . $column, $direction);
                         }
                     } else {
                         $query->addSortOrder($field, $direction);
                     }
                 }
             }
         }
         // Before we fetch the collection, lets check for filters
         if ($request->query->has('filter')) {
             $filter = $request->query->get('filter');
             if (is_array($filter)) {
                 foreach (array_keys($filter) as $prettyField) {
                     // lets start by making sure the field exists
                     // we explode, because we have a potential field with a column (like address.city) as opposed to just a field (like name)
                     $prettyFieldParts = explode('.', $prettyField);
                     if (array_key_exists($prettyFieldParts[0], $prettyToFieldsMap)) {
                         $field = $prettyToFieldsMap[$prettyFieldParts[0]];
                         $operator = null;
                         $value = null;
                         $filterValue = $filter[$prettyField];
                         // the filter value can either be the specific value, or an array with extra attributes
                         if (is_array($filterValue)) {
                             // we found an array, meaning we must check for 'operator' as well
                             $operator = array_key_exists('operator', $filterValue) && Condition::isValidSingleModelOperator($filterValue['operator']) ? $filterValue['operator'] : null;
                             $value = array_key_exists('value', $filterValue) ? $filterValue['value'] : null;
                         } else {
                             // no array, so it will just be the value
                             $operator = '=';
                             $value = $filterValue;
                         }
                         if (!empty($operator) && !empty($value) && !empty($field)) {
                             if (sizeof($prettyFieldParts) > 1) {
                                 // this means we have a field with a column (like address.city)
                                 $typePrettyToFieldsMap = $modelClassName::getTypePrettyFieldToFieldsMapping();
                                 // meaning we have a extra column present
                                 $fieldDefinition = $modelClassName::getFieldDefinition($field);
                                 $fieldType = $fieldDefinition->getType();
                                 if (array_key_exists($fieldType, $typePrettyToFieldsMap) && array_key_exists($prettyFieldParts[1], $typePrettyToFieldsMap[$fieldType])) {
                                     $column = $typePrettyToFieldsMap[$fieldType][$prettyFieldParts[1]];
                                     $condition = new Condition($field . '.' . $column, $operator, $value);
                                     $query->addCondition($condition);
                                 }
                             } else {
                                 // just a field, no column (like name)
                                 $condition = new Condition($field, $operator, $value);
                                 $query->addCondition($condition);
                             }
                         }
                     }
                 }
             }
         }
         // Here we build the links of the request
         $this->addSingleLink($jsonapi, 'self', $baseUrl, $limit, $page, $sort);
         // here we add the self link
         $result = $query->fetchCollection();
         if (!$result->isEmpty) {
             // we must include pagination links when there are more than the maximum amount of results
             if ($result->size === $this->maxLimit) {
                 $previousPage = empty($page) ? 0 : $page - 1;
                 // the first link is easy, it is the first page
                 $this->addSingleLink($jsonapi, 'first', $baseUrl, 0, 1, $sort);
                 // the previous link, checks if !empty, so pages with value 0 will not be displayed
                 if (!empty($previousPage)) {
                     $this->addSingleLink($jsonapi, 'previous', $baseUrl, 0, $previousPage, $sort);
                 }
                 // next we check the total count, to see if we can display the last & next link
                 $totalCount = $query->fetchTotalCount();
                 if (!empty($totalCount)) {
                     $lastPage = ceil($totalCount / $this->maxLimit);
                     $currentPage = empty($page) ? 1 : $page;
                     $this->addSingleLink($jsonapi, 'last', $baseUrl, 0, $lastPage, $sort);
                     // let's include some meta data
                     $jsonapi->addMeta('count', (int) $result->size);
                     $jsonapi->addMeta('total-count', (int) $totalCount);
                     $jsonapi->addMeta('page-count', (int) $lastPage);
                     $jsonapi->addMeta('page-size', (int) $this->maxLimit);
                     $jsonapi->addMeta('page-current', (int) $currentPage);
                     if (!empty($previousPage)) {
                         $jsonapi->addMeta('page-prev', (int) $previousPage);
                     }
                     // and finally, we also check if the next page isn't larger than the last page
                     $nextPage = empty($page) ? 2 : $page + 1;
                     if ($nextPage <= $lastPage) {
                         $this->addSingleLink($jsonapi, 'next', $baseUrl, 0, $nextPage, $sort);
                         $jsonapi->addMeta('page-next', (int) $nextPage);
                     }
                     $jsonapi->addMeta('result-row-first', (int) (($currentPage - 1) * $this->maxLimit) + 1);
                     $jsonapi->addMeta('result-row-last', (int) $result->size < $this->maxLimit ? ($currentPage - 1) * $this->maxLimit + $result->size : $currentPage * $this->maxLimit);
                 }
             } else {
                 if (!empty($limit)) {
                     // we must also include pagination links when we have a limit defined
                     $previousPage = empty($page) ? 0 : $page - 1;
                     // the first link is easy, it is the first page
                     $this->addSingleLink($jsonapi, 'first', $baseUrl, $limit, 1, $sort);
                     // the previous link, checks if !empty, so pages with value 0 will not be displayed
                     if (!empty($previousPage)) {
                         $this->addSingleLink($jsonapi, 'prev', $baseUrl, $limit, $previousPage, $sort);
                     }
                     // next we check the total count, to see if we can display the last & next link
                     $totalCount = $query->fetchTotalCount();
                     if (!empty($totalCount)) {
                         $lastPage = ceil($totalCount / $limit);
                         $currentPage = empty($page) ? 1 : $page;
                         $this->addSingleLink($jsonapi, 'last', $baseUrl, $limit, $lastPage, $sort);
                         // let's include some meta data
                         $jsonapi->addMeta('count', (int) $result->size);
                         $jsonapi->addMeta('total-count', (int) $totalCount);
                         $jsonapi->addMeta('page-count', (int) $lastPage);
                         $jsonapi->addMeta('page-size', (int) $limit);
                         $jsonapi->addMeta('page-current', (int) $currentPage);
                         if (!empty($previousPage)) {
                             $jsonapi->addMeta('page-prev', (int) $previousPage);
                         }
                         // and finally, we also check if the next page isn't larger than the last page
                         $nextPage = empty($page) ? 2 : $page + 1;
                         if ($nextPage <= $lastPage) {
                             $this->addSingleLink($jsonapi, 'next', $baseUrl, $limit, $nextPage, $sort);
                             $jsonapi->addMeta('page-next', (int) $nextPage);
                         }
                         $jsonapi->addMeta('result-row-first', (int) (($currentPage - 1) * $limit) + 1);
                         $jsonapi->addMeta('result-row-last', (int) $result->size < $limit ? ($currentPage - 1) * $limit + $result->size : $currentPage * $limit);
                     }
                 } else {
                     $jsonapi->addMeta('count', (int) $result->size);
                     $jsonapi->addMeta('total-count', (int) $result->size);
                     $jsonapi->addMeta('page-count', (int) 1);
                     $jsonapi->addMeta('page-size', (int) $this->maxLimit);
                     $jsonapi->addMeta('page-current', (int) 1);
                     $jsonapi->addMeta('result-row-first', (int) 1);
                     $jsonapi->addMeta('result-row-last', (int) $result->size);
                 }
             }
             $node = $result->getJsonApiNode();
             $jsonapi->setData($node);
             if ($request->query->has('include')) {
                 // includes are comma seperated
                 $includes = explode(',', $request->query->get('include'));
                 if (!empty($includes)) {
                     $this->checkForIncludes($result, $jsonapi, $includes);
                 }
             }
         }
     } else {
         $query->addCondition(new Condition($modelClassName::$idField, '=', $this->slug));
         $result = $query->fetchSingleModel();
         $this->addSingleLink($jsonapi, 'self', $baseUrl);
         if (!empty($result)) {
             $jsonapi->addNode($result->getJsonApiNode());
             // let's check for includes as well
             if ($request->query->has('include')) {
                 // includes are comma seperated
                 $includes = explode(',', $request->query->get('include'));
                 if (!empty($includes)) {
                     $this->checkForIncludes($result, $jsonapi, $includes);
                 }
             }
         } else {
             // we musn't do anything, json api provides an empty node out of the box
         }
     }
     return new Response(json_encode($jsonapi->serialize()), 200, array());
 }
 /**
  * Insert action
  */
 public function insertAction(Request $request)
 {
     $email = $request->request->filter('email', null, false, FILTER_VALIDATE_EMAIL);
     $existingUser = $this->container->getDoctrine()->getRepository('CmsAuthentication:User')->findOneByEmail($email);
     if (!empty($existingUser)) {
         throw new CmsException(null, 'User with this email is already registered!');
     }
     $name = $request->request->get('name');
     $dummyGroupId = $request->request->get('group');
     $groupName = $this->dummyGroupIdToGroupName($dummyGroupId);
     $group = $this->container->getDoctrine()->getRepository('CmsAuthentication:Group')->findOneByName($groupName);
     //		$this->checkActionPermission($group, Group::PERMISSION_MODIFY_USER_NAME);
     $user = new User();
     $user->setLogin($email);
     $user->setName($name);
     $user->setEmail($email);
     $user->setGroup($group);
     $password = substr(md5(rand() . time()), 0, 8);
     $user->setPassword($this->encodePassword($user, $password));
     $this->container->getDoctrine()->getManager()->flush();
     $message = \Swift_Message::newInstance('SiteSupra new user', sprintf('Hi %s, you are registered to SiteSupra at %s, your password is: %s', $user->getLogin(), $request->getSchemeAndHttpHost(), $password));
     $message->setTo($user->getEmail());
     $message->setFrom($this->container->getParameter('framework.swiftmailer.default_from'));
     $this->container->getMailer()->send($message);
     $this->container->getDoctrine()->getManager()->persist($user);
     $this->container->getDoctrine()->getManager()->flush();
     return new SupraJsonResponse(array('user_id' => $user->getId()));
 }