/** * @param $route_alias * @param $args * @return string */ public function url($route_alias, $args = array()) { $routes = $this->router->getRoutes(); $context = new RequestContext(self::getAssetDirectory()); $generator = new UrlGenerator($routes, $context); return $generator->generate($route_alias, $args); }
protected function getRouteUrl($name) { if (!isset($this->urlGenerator)) { throw new \Exception("URLGenerator was not set"); } return $this->urlGenerator->generate($name); }
/** * @Route("/url/{route}", bind="url", values={"route"=null}) */ public function urlAction($route) { if (null === $route) { $route = 'hello_name'; } return $this->urlGenerator->generate($route, array('name' => 'urs'), UrlGeneratorInterface::ABSOLUTE_URL); }
public function testAbsoluteSecureUrlWithNonStandardPort() { $this->routeCollection->add('test', new Route('/testing')); $this->generator->setContext(array('base_url' => '/app.php', 'method' => 'GET', 'host' => 'localhost', 'port' => 8080, 'is_secure' => true)); $url = $this->generator->generate('test', array(), true); $this->assertEquals('https://localhost:8080/app.php/testing', $url); }
/** * @param GetResponseForExceptionEvent $event */ public function onKernelException(GetResponseForExceptionEvent $event) { $exception = $event->getException(); if ($exception instanceof NotInstalledException) { $response = new RedirectResponse($this->urlGenerator->generate('simplr_install_welcome')); $event->setResponse($response); return; } }
public function loginAction(Request $req, Twig_Environment $twig, SecurityContext $sc, UrlGenerator $urlgen) { if ($sc->isGranted('IS_AUTHENTICATED_FULLY')) { return new RedirectResponse($urlgen->generate('home')); } else { $session = $req->getSession(); $errorConst = $sc::AUTHENTICATION_ERROR; $lastUsernameConst = $sc::LAST_USERNAME; return $twig->render('login.html.twig', array('error' => $session->has($errorConst) ? $session->get($errorConst)->getMessage() : null, 'last_username' => $session->get($lastUsernameConst))); } }
public function path($routeName, $parameters = array()) { /** @var Route $route */ $route = $this->routes->get($routeName); if ($route) { $context = new RequestContext(); $generator = new UrlGenerator($this->routes, $context); return $generator->generate($routeName, $parameters); } return ''; }
public static function generateURI($tag, $args = NULL) { $request = Request::createFromGlobals(); $locator = new FileLocator(array(__DIR__)); $loader = new YamlFileLoader($locator); $routes = $loader->load('../config/routes.yml'); $context = new RequestContext($request->getBaseUrl()); $generator = new UrlGenerator($routes, $context); $url = $generator->generate($tag); return $url; }
public function generate($name, $parameters = [], $referenceType = self::ABSOLUTE_PATH) { if ($this->locale !== null && !isset($parameters[RouteAttribute::LOCALE])) { $parameters[RouteAttribute::LOCALE] = $this->locale; } return parent::generate($name, $parameters, $referenceType); }
/** * {@override} */ protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $absolute) { if (is_object($parameters)) { $parameters = $this->readObjectParameters($parameters, $variables); } return parent::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $absolute); }
public function testListBucket() { $this->authorize(); $listUrl = $this->urlGenerator->generate('list', ['bucket' => 'foo']); $listBuckets = new Result(['Buckets' => [['Name' => 'foo', 'CreationDate' => '2014-08-01T14:00:00.000Z'], ['Name' => 'bar', 'CreationDate' => '2014-07-31T20:30:40.000Z']]]); $listObjects = new Result(['Contents' => [['Key' => 'baz', 'ETag' => '"' . md5('baz') . '"', 'LastModified' => '2014-09-10T11:12:13.000Z', 'Size' => 1024], ['Key' => 'qux', 'ETag' => '"' . md5('qux') . '"', 'LastModified' => '2014-09-11T21:22:23.000Z', 'Size' => 2048], ['Key' => 'quxx', 'ETag' => '"' . md5('quxx') . '"', 'LastModified' => '2014-09-12T00:00:00.000Z', 'Size' => 512]], 'IsTruncated' => false]); $this->s3ClientMock->expects($this->once())->method('listBuckets')->willReturn($listBuckets); $this->s3ClientMock->expects($this->once())->method('listObjects')->willReturn($listObjects); $crawler = $this->client->request('GET', $listUrl); $this->assertTrue($this->client->getResponse()->isOk()); // buckets $list = $crawler->filter('#list-bucket li'); $active = $list->filter('.active'); $this->assertCount(count($listBuckets['Buckets']), $list); $this->assertCount(1, $active); $this->assertEquals($list->eq(0), $active); $urlGenerator = $this->urlGenerator; $list->each(function (Crawler $bucket, $index) use($urlGenerator, $listBuckets) { $link = $bucket->filter('a'); $expectedName = $listBuckets['Buckets'][$index]['Name']; $this->assertEquals($expectedName, $link->text()); $this->assertEquals($urlGenerator->generate('list', ['bucket' => $expectedName]), $link->attr('href')); }); // objects $list = $crawler->filter('#list-object tbody tr'); $this->assertCount(count($listObjects['Contents']), $list); $list->each(function (Crawler $object, $index) use($listObjects) { $link = $object->filter('td')->eq(0)->filter('a'); $expectedKey = $listObjects['Contents'][$index]['Key']; $this->assertEquals($expectedKey, $link->text()); $this->assertEquals('http://foo.s3.amazonaws.com/' . $expectedKey, $link->attr('href')); $this->assertEquals($listObjects['Contents'][$index]['Size'], $object->filter('td')->eq(1)->text()); }); }
/** * {@inheritdoc} */ public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { // determine the most suitable locale to use for route generation $currentLocale = $this->context->getParameter('_locale'); if (isset($parameters['_locale'])) { $locale = $parameters['_locale']; } else { if ($currentLocale) { $locale = $currentLocale; } else { $locale = 'en'; } } try { if (false !== ($pos = strpos($name, I18nControllerCollection::ROUTING_PREFIX))) { $name = substr($name, $pos + strlen(I18nControllerCollection::ROUTING_PREFIX)); } $url = parent::generate($locale . I18nControllerCollection::ROUTING_PREFIX . $name, $parameters, $referenceType); return $url; } catch (RouteNotFoundException $ex) { // fallback to default behavior } // use the default behavior if no localized route exists return parent::generate($name, $parameters, $referenceType); }
/** * Get the URL to a named route. * * @param string $name * @param array $parameters * @param bool $absolute * @return string */ public function route($name, $parameters = array(), $absolute = true) { $route = $this->routes->get($name); if (isset($route) and $this->usingQuickParameters($parameters)) { $parameters = $this->buildParameterList($route, $parameters); } return $this->generator->generate($name, $parameters, $absolute); }
/** * {@inheritdoc} */ public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { $url = parent::generate($name, $parameters, $referenceType); if (substr($url, -6) == '/index') { $url = rtrim($url, "index"); } return $url; }
public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { try { return parent::generate($name, $parameters, $referenceType); } catch (RouteNotFoundException $e) { return $this->generator->generate($name, $parameters, $referenceType); } }
public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { if (null === $this->namespace || !$referenceType) { return parent::generate($name, $parameters, $referenceType); } else { return $this->getBaseUrl() . parent::generate($name, $parameters, false); } }
public function generate($name, array $parameters = array(), $absolute = false) { if (null === $this->namespace || !$absolute) { return parent::generate($name, $parameters, $absolute); } else { return $this->getBaseUrl() . parent::generate($name, $parameters, false); } }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $container->setParameter('hearsay_require_js.require_js_src', $config['require_js_src']); $container->setParameter('hearsay_require_js.initialize_template', $config['initialize_template']); $container->setParameter('hearsay_require_js.base_url', $config['base_url']); $container->setParameter('hearsay_require_js.base_dir', $this->getRealPath($config['base_dir'], $container)); // Add the base directory as an empty namespace $config['paths'][''] = array('location' => $config['base_dir'], 'external' => false); $hideUnoptimizedAssets = !isset($config['optimizer']['hide_unoptimized_assets']) ? false : $config['optimizer']['hide_unoptimized_assets']; // By using this flag as true, defines will be declared as their module names $declareModuleName = !isset($config['optimizer']['declare_module_name']) ? false : $config['optimizer']['declare_module_name']; $container->setParameter('hearsay_require_js.declare_module_name', $declareModuleName); foreach ($config['paths'] as $path => $settings) { $location = $settings['location']; if ($settings['external']) { $this->addExternalNamespaceMapping($location, $path, $container); } else { is_array($location) && ($location = array_shift($location)); $this->addNamespaceMapping($location, $path, $container, !$hideUnoptimizedAssets); } } $container->setParameter('hearsay_require_js.shim', $config['shim']); $configurationBuilder = $container->getDefinition('hearsay_require_js.configuration_builder'); foreach ($config['options'] as $option => $settings) { $configurationBuilder->addMethodCall('addOption', array($option, $settings['value'])); } if (!isset($config['optimizer'])) { // If the r.js optimizer config isn't provided, don't provide the Assetic filter $container->removeDefinition('hearsay_require_js.optimizer_filter'); } else { $container->setParameter('hearsay_require_js.r.path', $this->getRealPath($config['optimizer']['path'], $container)); $filter = $container->getDefinition('hearsay_require_js.optimizer_filter'); if ($config['optimizer']['almond_path']) { // Makes almond path relative to base directory for r.js optimization $almondPath = UrlGenerator::getRelativePath($container->getParameter('hearsay_require_js.base_dir'), $this->getRealPath($config['optimizer']['almond_path'], $container)); // Removes file extension if it exists $almondPath = preg_replace('/\\.js$/', '', $almondPath); $filter->addMethodCall('setAlmondPath', array($almondPath)); $configurationBuilder->addMethodCall('setUseAlmond', array(true)); } $filter->addMethodCall('setShim', array($config['shim'])); $filter->addMethodCall('setTimeout', array($config['optimizer']['timeout'])); foreach ($config['optimizer']['exclude'] as $exclude) { $filter->addMethodCall('addExclude', array($exclude)); } foreach ($config['optimizer']['modules'] as $name => $module) { $filter->addMethodCall('addModule', array($name, $module)); } foreach ($config['optimizer']['options'] as $name => $settings) { $filter->addMethodCall('addOption', array($name, $settings['value'])); } } }
/** * @throws MissingMandatoryParametersException When route has some missing mandatory parameters * @throws InvalidParameterException When a parameter value is not correct */ protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, array $requiredSchemes = []) { $baseUrl = $this->getContext()->getBaseUrl(); if ($name[0] != '_' && ($locale = $this->getContext()->getParameter('_locale'))) { $this->getContext()->setBaseUrl($baseUrl . '/' . $locale); } $result = parent::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, $requiredSchemes); $this->getContext()->setBaseUrl($baseUrl); return $result; }
/** * @Route("/delete/{id}", bind="example_delete", asserts={"name"="\d+"}) * @param $id * @return RedirectResponse * @throws NotFoundHttpException */ public function deleteAction($id) { $example = $this->doctrine->getManager()->getRepository(get_class(new Example()))->find($id); if (is_null($example)) { throw new NotFoundHttpException("Can't find example with id {$id}"); } $this->doctrine->getManager()->remove($example); $this->doctrine->getManager()->flush(); return new RedirectResponse($this->urlGenerator->generate('example_list'), 302); }
public function execute(InputInterface $input, OutputInterface $output) { $container = $this->getContainer(); $tubeManipulator = $container->get('velikan_tube_crawler.tube_manipulator'); $tubes = []; if ($tubeId = $input->hasArgument('tube-id')) { $tubes[] = $tubeManipulator->find($tubeId); } else { $tubes = $tubeManipulator->findAll(); } $uriFetchAdapter = $container->get('velikan_tube_crawler.uri_fetch_adapter'); $parsedVideoCounter = 0; $videoParser = $container->get('velikan_tube_crawler.video_parser'); /** @var Tube $tube */ $tube = null; $fetchAdapterFunction = function ($responseBody, $pageIndex) use(&$tube, $tubeManipulator, $videoParser, $output, &$parsedVideoCounter) { $videos = $videoParser->parse($responseBody, $tube->getVideoBlockSelector(), $tube->getVideoUriSelector(), $tube->getVideoImageSelector(), $tube->getVideoTitleSelector()); foreach ($videos as $parsedVideo) { $video = new Video(); $video->setTube($tube); $video->setVideoUri($parsedVideo['uri']); $video->setImageUri($parsedVideo['image']); $video->setTitle($parsedVideo['title']); $tubeManipulator->testAndCreateVideo($video); } $parsedVideoCounter += count($videos); $output->writeln(sprintf('Parsed %d videos for page %d (%d overall)', count($videos), $pageIndex, $parsedVideoCounter)); }; /** @var Tube $tube */ foreach ($tubes as $tube) { $output->writeln('Fetching videos for <info>' . $tube->getName() . '</info>'); $routeCollection = new RouteCollection(); $routeCollection->add('uri', new Route($tube->getUrn())); $requestContext = new RequestContext(Tube::$schemeList[$tube->getScheme()] . '://' . $tube->getHost()); $generator = new UrlGenerator($routeCollection, $requestContext); $startingPageNumber = $tube->getStartingPageNumber(); for ($i = $startingPageNumber; $i < $input->getOption('pages') + $startingPageNumber; $i++) { $uri = urldecode($generator->generate('uri', ['page' => $i])); $uriFetchAdapter->addUri($uri); } $uriFetchAdapter->fetch($fetchAdapterFunction, $tube->getCanFetchMultithreaded(), $tube->getThreadCount()); } }
/** * @inheritdoc */ public function getRouteUrl($route, $parameters = null) { // Convert non-array parameters to empty array or single-value array with default parameter name. if (is_null($parameters)) { $parameters = array(); } elseif (!is_array($parameters)) { $parameters = array($this->getDefaultRouteParameterName() => $parameters); } // Generate the URL $configuredRoute = $this->config(sprintf('routes.%s', $route), $route); // TODO Allow configuration between absolute URL, absolute path, network URL, relative path, and path relative to base return $this->urlGenerator->generate($configuredRoute, $parameters, UrlGenerator::ABSOLUTE_URL); }
/** * {@inheritdoc} */ protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, array $requiredSchemes = []) { $link = $name; if ($params = array_intersect_key($parameters, array_flip(isset($defaults['_variables']) ? $defaults['_variables'] : $variables))) { $link .= '?' . http_build_query($params); if ($properties = $this->getRouteProperties($link)) { list($variables, $defaults, $requirements, $tokens, $hostTokens, $requiredSchemes) = $properties; } } if ($referenceType === self::LINK_URL) { return $link; } return parent::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, $requiredSchemes); }
public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { // Check if this URL needs a CSRF token. if (null !== ($route = $this->routes->get($name))) { if ($csrfField = $route->getDefault(Route::CSRF_ATTRIBUTE_NAME)) { $parameters[$csrfField] = $route->getCsrfToken($name, $parameters, $this->_session->getId(), $this->_pepper); } } array_walk($parameters, function (&$item) { if ($item instanceof Slug) { $item = (string) $item; $item = $item === '/' ? $item : ltrim($item, '/'); } }); return parent::generate($name, $parameters, $referenceType); }
/** * @param $variables * @param $defaults * @param $requirements * @param $tokens * @param $parameters * @param $name * @param $referenceType * @param $hostTokens * @param array $requiredSchemes * @return null|string */ protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, array $requiredSchemes = []) { if (is_object($parameters)) { $object = $parameters; $parameters = []; } elseif (isset($parameters['object']) && is_object($parameters['object'])) { $object = $parameters['object']; unset($parameters['object']); } if (isset($object)) { $mergedParams = array_replace($defaults, $this->context->getParameters(), $parameters); $requiredParams = array_diff_key(array_flip($variables), $mergedParams); $parameters += $this->getParametersFromObject(array_keys($requiredParams), $object); } return BaseUrlGenerator::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, $requiredSchemes); }
/** * Surcharge de l'url generator pour générer une route en fonction d'un objet (paramètre _object) * Les paramètres passés directement à la route sont prioritaires par rapport aux champs de _object * {@inheritdoc} */ protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, array $requiredSchemes = []) { if (isset($defaults['_external']) && '' !== $this->context->getBaseUrl()) { $oldBaseUrl = $this->context->getBaseUrl(); $this->context->setBaseUrl(''); } if (isset($parameters['_object'])) { $object = $parameters['_object']; $parameters = array_merge($this->getParametersFromObject($variables, $object), $parameters); unset($parameters['_object']); } $url = parent::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $referenceType, $hostTokens, $requiredSchemes); if (isset($oldBaseUrl)) { $this->context->setBaseUrl($oldBaseUrl); } return $url; }
public function generate($name, array $parameters = array(), $referenceType = self::ABSOLUTE_PATH, $scheme = null) { $contextParameters = array_deep_merge($this->sessionDefaultParameters, $this->defaultParameters, $this->context->getParameters()); $oldContextParameters = $this->context->getParameters(); $this->context->setParameters($contextParameters); $oldScheme = null; if ($scheme) { $oldScheme = $this->context->getScheme(); $this->context->setScheme($scheme); } $oldHost = $this->context->getHost(); $context = $this->context; $finalize = new OutOfScopeFinalize(function () use($oldContextParameters, $oldScheme, $oldHost, $context, $scheme) { if ($scheme) { $context->setScheme($oldScheme); } $context->setHost($oldHost); $context->setParameters($oldContextParameters); }); $cultures = $this->getCultures(array_merge($contextParameters, $parameters)); $route = null; foreach ($cultures as $culture) { $routeName = $this->getI18nRouteName($name, $culture); if ($this->routeCollection->get($routeName)) { try { $host = $this->getHostForCulture($culture == '' ? 'default' : $culture); $this->context->setHost($host); if ($host != $oldHost) { $referenceType = self::ABSOLUTE_URL; } } catch (NoHostFoundForCultureException $e) { //We do nothing with the exception, it will use the request domain } $route = $this->urlGenerator->generate($routeName, $parameters, $referenceType); break; } } if (is_null($route)) { $route = $this->urlGenerator->generate($name, $parameters); } return $route; }
/** * {@inheritdoc} */ public function generate($name, $parameters = [], $referenceType = self::ABSOLUTE_PATH) { // Determine the most suitable locale to use for route generation $currentLocale = $this->context->getParameter('_locale'); if (isset($parameters['_locale'])) { $locale = $parameters['_locale']; } elseif ($currentLocale) { $locale = $currentLocale; } else { $locale = $this->defaultLocale; } try { $i18nRouteName = sprintf('%s%s%s', $locale, I18nLoader::ROUTING_PREFIX, $name); $url = parent::generate($i18nRouteName, $parameters, $referenceType); return $url; } catch (RouteNotFoundException $e) { // Nothing to do } return parent::generate($name, $parameters, $referenceType); }
/** * {@inheritDoc} * @param $name string * @param $parameters array * @param $referenceType boolean|integer * @see \Symfony\Component\Routing\Generator\UrlGenerator::generate() */ public function generate($name, $parameters = array(), $referenceType = false) { //Since Symfony 3 dropped compatibility for booleans //and completely swapped the logic, let's provide our own compatibility layer. //We only want to touch booleans. Let proper integer-constant calls to go through. if ($referenceType === true) { $referenceType = UrlGeneratorInterface::ABSOLUTE_URL; } else { if ($referenceType === false) { $referenceType = UrlGeneratorInterface::ABSOLUTE_PATH; } } $route = $this->routes->get($name); if ($route instanceof Route) { $isRouteLocaleAware = strpos($route->getPath(), '{locale}') !== false; if ($isRouteLocaleAware) { if (!array_key_exists('locale', $parameters)) { try { $parameters['locale'] = $this->getRequest()->getLocale(); } catch (\RuntimeException $e) { //Not running in a request context. } } } else { //Route that doesn't take a locale. If one was provided, get rid of it. //This is necessary, because we put certain systems into single-locale mode //(and transparently remove {locale} from routes. //Still, some code passes locales around.. But the routes no longer need it. //Instead of fixing all these passers so that they don't pass when in single-locale mode, //we do this transparently here. // //Caveat: If someone uses a non-locale-aware route, but wants a `locale` query string, //(`locale` meaning something possibly-unrelated to this library), //we would strip it as well and not pass it along. //This is a known problem. We take over `locale` and don't let people use it when they //include this library. unset($parameters['locale']); } } return parent::generate($name, $parameters, $referenceType); }
/** * @param string $name * @param array $parameters * @param int $referenceType * * @return string */ public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH) { if (isset($parameters[self::REDIRECT_TO_LANGUAGE])) { try { $name = $this->nodeManager->getNodeRouteName($name, $parameters[self::REDIRECT_TO_LANGUAGE]); } catch (NodeNotFoundException $e) { throw new RouteNotFoundException(sprintf('Unable to generate a URL for the named route "%s" as such route does not exist.', $name)); } unset($parameters[self::REDIRECT_TO_LANGUAGE]); return parent::generate($name, $parameters, $referenceType); } $site = $this->siteRepository->findOneBySiteId($this->currentSiteManager->getCurrentSiteId()); if (null === $site) { throw new RouteNotFoundException(sprintf('Unable to generate a URL for the named route "%s" as such route does not exist.', $name)); } $aliasId = $site->getMainAliasId(); $request = $this->requestStack->getMasterRequest(); if ($request) { $aliasId = $request->get('aliasId', $aliasId); } $uri = parent::generate($aliasId . '_' . $name, $parameters, $referenceType); return $uri; }