/** * {@inheritdoc} */ public function processOutbound($route_name, Route $route, array &$parameters, BubbleableMetadata $bubbleable_metadata = NULL) { if ($route_name === '<current>') { if ($current_route = $this->routeMatch->getRouteObject()) { $requirements = $current_route->getRequirements(); // Setting _method and _schema is deprecated since 2.7. Using // setMethods() and setSchemes() are now the recommended ways. unset($requirements['_method']); unset($requirements['_schema']); $route->setRequirements($requirements); $route->setPath($current_route->getPath()); $route->setSchemes($current_route->getSchemes()); $route->setMethods($current_route->getMethods()); $route->setOptions($current_route->getOptions()); $route->setDefaults($current_route->getDefaults()); $parameters = array_merge($parameters, $this->routeMatch->getRawParameters()->all()); if ($bubbleable_metadata) { $bubbleable_metadata->addCacheContexts(['route']); } } else { // If we have no current route match available, point to the frontpage. $route->setPath('/'); } } }
/** * @SuppressWarnings(PHPMD.UnusedFormalParameter) * * @param mixed $resource * @param null $type * * @return RouteCollection */ public function load($resource, $type = null) : RouteCollection { $resource = (string) $resource; if (in_array($resource, $this->descriptions)) { throw new \RuntimeException("Resource '{$resource}' was already loaded"); } $description = $this->repository->get($resource); $routes = new RouteCollection(); $router = $description->getExtension('router') ?: 'swagger.controller'; $routerController = $description->getExtension('router-controller'); foreach ($description->getPaths() as $pathItem) { $relativePath = ltrim($pathItem->getPath(), '/'); $resourceName = strpos($relativePath, '/') ? substr($relativePath, 0, strpos($relativePath, '/')) : $relativePath; $routerController = $pathItem->getExtension('router-controller') ?: $routerController; foreach ($pathItem->getOperations() as $operation) { $controllerKey = $this->resolveControllerKey($operation, $resourceName, $router, $routerController); $defaults = ['_controller' => $controllerKey, RequestMeta::ATTRIBUTE_URI => $resource, RequestMeta::ATTRIBUTE_PATH => $pathItem->getPath()]; $route = new Route($pathItem->getPath(), $defaults, $this->resolveRequirements($operation)); $route->setMethods($operation->getMethod()); $routes->add($this->createRouteId($resource, $pathItem->getPath(), $controllerKey), $route); } } $this->descriptions[] = $resource; return $routes; }
/** * @param Method $method * @param string $endpoint * * @return RpcApiDoc */ protected function processMethod(Method $method, $endpoint) { /** @var string[] $views */ $views = $method->getContext(); if ($method->includeDefaultContext()) { $views[] = 'Default'; } $views[] = 'default'; $request = new Request($method, [], new ParameterBag(['_controller' => $method->getController()])); /** @var array $controller */ $controller = $this->resolver->getController($request); $refl = new \ReflectionMethod($controller[0], $controller[1]); /** @var RpcApiDoc $methodDoc */ $methodDoc = $this->reader->getMethodAnnotation($refl, RpcApiDoc::class); if (null === $methodDoc) { $methodDoc = new RpcApiDoc(['resource' => $endpoint]); } $methodDoc = clone $methodDoc; $methodDoc->setEndpoint($endpoint); $methodDoc->setRpcMethod($method); if (null === $methodDoc->getSection()) { $methodDoc->setSection($endpoint); } foreach ($views as $view) { $methodDoc->addView($view); } $route = new Route($endpoint); $route->setMethods([$endpoint]); $route->setDefault('_controller', get_class($controller[0]) . '::' . $controller[1]); $methodDoc->setRoute($route); return $methodDoc; }
/** * Given an array of RAML\Resources, this function will add each Resource * into the Symfony Route Collection, and set the corresponding method. * * @param BasicRoute[Resource] $resources * Associative array where the key is the method and full path, and the value contains * the path, method type (GET/POST etc.) and then the Raml\Method object * * @return array */ public function format(array $resources) { // Loop over the Resources foreach ($resources as $path => $resource) { // This is the path from the RAML, with or without a /. $path = $resource->getUri() . ($this->addTrailingSlash ? '/' : ''); // This is the baseUri + path, the complete URL. $url = $resource->getBaseUrl() . $path; // Now remove the host away, so we have the FULL path to the resource. // baseUri may also contain path that has been omitted for brevity in the // RAML creation. $host = parse_url($url, PHP_URL_HOST); $fullPath = substr($url, strpos($url, $host) + strlen($host)); // Now build our Route class. $route = new Route($fullPath); $route->setMethods($resource->getMethod()->getType()); $route->setSchemes($resource->getProtocols()); // Loop over each of the URI Parameters searching for validation patterns // or default values for parameters. foreach ($resource->getUriParameters() as $name => $param) { $route->setRequirement($name, $param->getValidationPattern()); if ($default = $param->getDefault()) { $route->setDefault($name, $default); } } $this->routes->add($resource->getType() . ' ' . $path, $route); } return $resources; }
/** @test */ public function it_adds_input_for_dynamic_form_type() { $apiDoc = new ApiDoc([]); $generateApiDocAnnotation = new GenerateApiDoc([]); $route = new Route('/posts', ['_entity' => Post::class, '_roles' => ['ROLE_ADMIN']]); $route->setMethods(['POST']); $method = $this->getMockBuilder(\ReflectionMethod::class)->disableOriginalConstructor()->getMock(); $handler = new GenerateApiDocHandler($this->manager, $this->em, $this->router, $this->client->getContainer()); $handler->handle($apiDoc, [$generateApiDocAnnotation], $route, $method); $this->assertCount(5, $apiDoc->getParameters()); $this->assertEquals(Post::class, $apiDoc->getOutput()); }
/** * @param string $resource * @param null $type * * @return RouteCollection */ public function load($resource, $type = null) { if (true === $this->loaded) { throw new \RuntimeException('Do not add the "siab" loader twice'); } $routes = new RouteCollection(); $path = $this->container->getParameter('symfonian_id.admin.home.route_path'); $defaults = array('_controller' => $this->container->getParameter('symfonian_id.admin.home.controller')); $route = new Route($path, $defaults, array(), array('expose' => true)); $route->setMethods('GET'); $routes->add('home', $route); $this->loaded = true; return $routes; }
private function generateRouteCollection(ParameterBag $routes) : RouteCollection { $routeCollection = new RouteCollection(); foreach ($routes as $key => $route) { $pattern = explode('::', $route->route, 2); $sfRoute = new Route(isset($pattern[1]) ? $pattern[1] : $pattern[0]); if (isset($route->require)) { $sfRoute->setRequirements((array) $route->require); } if (isset($pattern[1])) { $sfRoute->setMethods(strtoupper($pattern[0])); } $routeCollection->add($key, $sfRoute); } return $routeCollection; }
/** {@inheritdoc} */ public function load($resource, $type = null) { if ($this->loaded) { throw new \LogicException('Endpoint loader is already loaded'); } $collection = new RouteCollection(); foreach ($this->endpoints as $name => $endpoint) { // prepare a new route $path = $endpoint['path']; $defaults = $endpoint['defaults']; $route = new Route($path, $defaults); $route->setMethods('POST'); $collection->add($name, $route); } $this->loaded = true; return $collection; }
/** * Extract route collection from config/routes.yml * * @return \Symfony\Component\Routing\RouteCollection */ public static function GetRouteCollection() { // create Symfony routing route collection $collection = new RouteCollection(); $routearray = new RouteArray(); $value = $routearray->getAll(); // fill collection foreach ($value as $name => $rte) { $rp = new RouteParser($rte, $name); if ($rp->parse()) { $defaults = $rp->getArrayParams(); $route = new Route($rp->getPattern(), $defaults); $route->setMethods($rp->getMethods()); $collection->add($name, $route); } } return $collection; }
/** * Configures the _controller default parameter and eventually the HTTP method * requirement of a given Route instance. * * @param Route $route A route instance * @param \ReflectionClass $class A ReflectionClass instance * @param \ReflectionMethod $method A ReflectionClass method * @param mixed $annot The annotation class instance * * @throws \LogicException When the service option is specified on a method */ protected function configureRoute(Route $route, \ReflectionClass $class, \ReflectionMethod $method, $annot) { // controller $classAnnot = $this->reader->getClassAnnotation($class, $this->routeAnnotationClass); if ($classAnnot instanceof FrameworkExtraBundleRoute && ($service = $classAnnot->getService())) { $route->setDefault('_controller', $service . ':' . $method->getName()); } else { $route->setDefault('_controller', $class->getName() . '::' . $method->getName()); } // requirements (@Method) foreach ($this->reader->getMethodAnnotations($method) as $configuration) { if ($configuration instanceof Method) { $route->setMethods(implode('|', $configuration->getMethods())); } elseif ($configuration instanceof FrameworkExtraBundleRoute && $configuration->getService()) { throw new \LogicException('The service option can only be specified at class level.'); } } }
/** * Given an array of RAML\Resources, this function will add each Resource * into the Symfony Route Collection, and set the corresponding method. * * @param BasicRoute[] $resources * Associative array where the key is the method and full path, and the value contains * the path, method type (GET/POST etc.) and then the Raml\Method object * * @return array */ public function format(array $resources) { foreach ($resources as $path => $resource) { // This is the path from the RAML, with or without a /. $path = $resource->getUri() . ($this->addTrailingSlash ? '/' : ''); // This is the baseUri + path, the complete URL. $url = $resource->getBaseUrl() . $path; // Now remove the host away, so we have the FULL path to the resource. // baseUri may also contain path that has been omitted for brevity in the // RAML creation. $host = parse_url($url, PHP_URL_HOST); $fullPath = substr($url, strpos($url, $host) + strlen($host)); // Now build our Route class. $route = new Route($fullPath); $route->setMethods($resource->getMethod()->getType()); $route->setSchemes($resource->getProtocols()); $this->routes->add($resource->getType() . ' ' . $path, $route); } return $resources; }
public function load($resource, $type = null) { $collection = new RouteCollection(); $resource = str_replace('\\', '/', $resource); $this->yaml = Yaml::parse(file_get_contents($this->getGeneratorFilePath($resource))); $namespace = $this->getNamespaceFromResource($resource); $bundle_name = $this->getBundleNameFromResource($resource); foreach ($this->actions as $controller => $datas) { $action = 'index'; $loweredNamespace = str_replace(array('/', '\\'), '_', $namespace); if ($controller_folder = $this->getControllerFolder($resource)) { $route_name = $loweredNamespace . '_' . $bundle_name . '_' . $controller_folder . '_' . $controller; } else { $route_name = $loweredNamespace . '_' . $bundle_name . '_' . $controller; } if (in_array($controller, array('edit', 'update', 'object', 'show')) && null !== ($pk_requirement = $this->getFromYaml('params.pk_requirement', null))) { $datas['requirements'] = array_merge($datas['requirements'], array('pk' => $pk_requirement)); } if (isset($datas['controller'])) { $action = $controller; $controller = $datas['controller']; } $controllerName = $resource . ucfirst($controller) . 'Controller.php'; if (!is_file($controllerName)) { // TODO: what does it mean if controller is not a file?? continue; } if ($controller_folder) { $datas['defaults']['_controller'] = $namespace . '\\' . $bundle_name . '\\Controller\\' . $controller_folder . '\\' . ucfirst($controller) . 'Controller::' . $action . 'Action'; } else { $datas['defaults']['_controller'] = $loweredNamespace . $bundle_name . ':' . ucfirst($controller) . ':' . $action; } $route = new Route($datas['path'], $datas['defaults'], $datas['requirements']); $route->setMethods($datas['methods']); $route_name = ltrim($route_name, '_'); // fix routes in AppBundle without vendor $collection->add($route_name, $route); $collection->addResource(new FileResource($controllerName)); } return $collection; }
public function dispatch() { // @todo - create the RouteCollection // @todo - run the matcher against this and get a route back $this->router = $this->serviceManager->get('MicroRouter'); $routeCollection = new RouteCollection(); foreach ($this->routes as $routeKey => $r) { $route = new Route($r['uri']); $route->setMethods($r['method']); $routeCollection->add($routeKey, $route); // @todo - dont md5() this. } $request = $this->getRequest(); $requestContext = $this->getServiceManager()->get('RouterRequestContext'); $requestContext->fromRequest($request); $matcher = new UrlMatcher($routeCollection, $requestContext); // @todo - try catch this $routeAttributes = $matcher->match($request->getPathInfo()); $matchedRouteKey = $routeAttributes['_route']; $this->routes[$matchedRouteKey]['callback']($this->getServiceManager()); // @todo - handle when the callback returns a Response object and send that to the client. return $this; }
private function createRoute($path, array $globals, array $options = []) { foreach ($globals as $k => $v) { if (is_array($v) && isset($options[$k])) { $options[$k] = array_merge($v, $options[$k]); } else { $options[$k] = isset($options[$k]) ? $options[$k] : $v; } } $route = new Route($path); if (isset($options['host'])) { $route->setHost($options['host']); } if (isset($options['defaults'])) { $route->setDefaults($options['defaults']); } if (isset($options['requirements'])) { $route->setRequirements($options['requirements']); } if (isset($options['methods'])) { $route->setMethods($options['methods']); } return $route; }
/** * @SuppressWarnings(PHPMD.UnusedFormalParameter) * * @param mixed $resource * @param null $type * * @return RouteCollection */ public function load($resource, $type = null) { $resource = (string) $resource; if (in_array($resource, $this->loadedSpecs)) { throw new \RuntimeException("Resource '{$resource}' was already loaded"); } $document = $this->documentRepository->get($resource); $routes = new RouteCollection(); foreach ($document->getPathDefinitions() as $path => $methods) { $relativePath = ltrim($path, '/'); $resourceName = strpos($relativePath, '/') ? substr($relativePath, 0, strpos($relativePath, '/')) : $relativePath; foreach ($methods as $methodName => $operationSpec) { $operationName = isset($operationSpec['operationId']) ? $operationSpec['operationId'] : $methodName; $defaults = ['_controller' => "swagger.controller.{$resourceName}:{$operationName}", '_definition' => $resource]; $requirements = []; $route = new Route($path, $defaults, $requirements); $route->setMethods($methodName); $routeName = "swagger.{$this->createRouteIdFromPath($path)}.{$operationName}"; $routes->add($routeName, $route); } } $this->loadedSpecs[] = $resource; return $routes; }
/** * @param $path * @param callable $function */ public static function post($path, \Closure $function) { $closureStorage = ClosureStorage::getInstance(); $routeName = self::getRouteNameFromPath($path, 'POST'); $closureStorage[$routeName] = $function; $collection = $collection = static::getRoutes(); $route = new Route($path, array(RouteInfo::CLOSURE => true)); $route->setMethods('POST'); $collection->add($routeName, $route); }
/** * Returns a Content-type restricted set of routes for testing. * * @return \Symfony\Component\Routing\RouteCollection */ public function contentRouteCollection() { $collection = new RouteCollection(); $route = new Route('path/three'); $route->setMethods(['POST']); $route->setRequirement('_content_type_format', 'json'); $collection->add('route_f', $route); $route = new Route('path/three'); $route->setMethods(['PATCH']); $route->setRequirement('_content_type_format', 'xml'); $collection->add('route_g', $route); return $collection; }
public function testMethod() { $route = new Route('/'); $this->assertEquals(array(), $route->getMethods(), 'methods is initialized with array()'); $route->setMethods('gEt'); $this->assertEquals(array('GET'), $route->getMethods(), '->setMethods() accepts a single method string and uppercases it'); $route->setMethods(array('gEt', 'PosT')); $this->assertEquals(array('GET', 'POST'), $route->getMethods(), '->setMethods() accepts an array of methods and uppercases them'); }
/** * Adds a route in a route collection. * @param string $path The path * @param string $controller The controller * @param string $method The method */ private function _addRoute($path, $controller, $method = '') { $route = new Route($path, ['controller' => $controller]); if ($method) { $route->setMethods($method); } $this->_routeCollection->add($path, $route); }
public function __construct() { $this->request = Request::createFromGlobals(); $this->container = Container::getInstance(); /* Parse params file - Begin */ $params = $this->parseYamlFile(APP_DIR . DS . 'configs' . DS . 'params.yml'); $isDev = $params['environment'] === 'development'; if ($isDev) { Debug::enable(E_STRICT); } date_default_timezone_set($params['timezone']); /* Parse params file - End */ /* Parse routes file - Begin */ $routes = $this->parseYamlFile(APP_DIR . DS . 'configs' . DS . 'routes.yml'); $collection = new RouteCollection(); foreach ($routes as $name => $options) { $parts = explode(':', $options['defaults']['_controller']); $options['defaults'] = array('_controller' => "{$parts[0]}\\Controllers\\{$parts[1]}Controller::{$parts[2]}Action"); $route = new Route($options['path']); $route->setDefaults($options['defaults']); $route->setRequirements(isset($options['requirements']) ? $options['requirements'] : array()); $route->setOptions(isset($options['options']) ? $options['options'] : array()); $route->setHost(isset($options['host']) ? $options['host'] : ''); $route->setSchemes(isset($options['schemes']) ? $options['schemes'] : array()); $route->setMethods(isset($options['methods']) ? $options['methods'] : array()); $route->setCondition(isset($options['condition']) ? $options['condition'] : ''); $collection->add($name, $route); } $this->container->setParameter('routes', $collection); /* Parse routes file - End */ /* Composer ClassLoader - Begin */ $composer_loader = new ClassLoader(); $composer_loader->addPsr4('Application\\Controllers\\', APP_DIR . DS . 'layers' . DS . 'controllers'); $composer_loader->addPsr4('Application\\Models\\', APP_DIR . DS . 'layers' . DS . 'models'); $composer_loader->register(); /* Composer ClassLoader - End */ /* Set error controller - Begin */ $namespace = $isDev ? 'Hideks\\Controller\\' : 'Application\\Controllers\\'; $this->container->setParameter('exception.controller', $namespace . 'ErrorController::exceptionAction'); /* Set error controller - End */ /* Assetic configuration setup - Begin */ $filter_manager = new FilterManager(); $filter_manager->set('css_min', new CssMinFilter()); $filter_manager->set('lessphp', new LessphpFilter()); $filter_manager->set('js_min', new JSMinFilter()); $asset_factory = new AssetFactory(APP_DIR . DS . 'assets' . DS); $asset_factory->setDebug($isDev); $asset_factory->setFilterManager($filter_manager); $asset_factory->addWorker(new CacheBustingWorker()); $this->container->setParameter('assetic.factory', $asset_factory); /* Assetic configuration setup - End */ /* Twig configuration setup - Begin */ $this->container->setParameter('twig.debug', $isDev); $this->container->setParameter('twig.cache', $isDev ? false : APP_DIR . DS . 'cache' . DS . 'twig'); $twig_loader = $this->container->get('twig.loader'); $twig_loader->addPath(APP_DIR . DS . 'layers' . DS . 'views'); /* Twig configuration setup - End */ /* Active Record configuration setup - Begin */ $active_record = \ActiveRecord\Config::instance(); $active_record->set_model_directory(APP_DIR . DS . 'layers' . DS . 'models'); $active_record->set_connections($params['connections']); $active_record->set_default_connection($params['environment']); /* Active Record configuration setup - End */ }
/** * Returns a new ApiDoc instance with more data. * * @param ApiDoc $annotation * @param Route $route * @param \ReflectionMethod $method * @param DunglasResource $dunglasResource * @return ApiDoc */ protected function extractData(ApiDoc $annotation, Route $route, \ReflectionMethod $method, DunglasResource $dunglasResource = null) { //remove methode OPTIONS $methods = $route->getMethods(); $optionIndex = array_search('OPTIONS', $methods); if ($optionIndex !== false) { unset($methods[$optionIndex]); $route->setMethods($methods); } if (in_array(strtolower($this->versionApi), $this->nelmioDocStandardVersion)) { return parent::extractData($annotation, $route, $method); } // create a new annotation $annotation = clone $annotation; $annotation->addTag($this->versionApi, '#ff0000'); // doc $annotation->setDocumentation($this->commentExtractor->getDocCommentText($method)); // parse annotations $this->parseAnnotations($annotation, $route, $method); $resource = $route->getDefault('_resource'); // route $annotation->setRoute($route); $entityClassInput = $entityClassOutput = null; //section $annotation->setSection($resource); $annotation = $this->addFilters($resource, $annotation, $dunglasResource, $route); if (in_array($annotation->getMethod(), ['POST', 'PUT'])) { $formName = 'api_v2_' . strtolower($dunglasResource->getShortName()); if ($hasFormtype = $this->registry->hasType($formName)) { $type = $this->registry->getType($formName); if ($type instanceof ResolvedFormTypeInterface) { $entityClassInput = get_class($type->getInnerType()); $dunglasResource->initValidationGroups($type->getInnerType()->validationGrp); } } } if ('GET' === $annotation->getMethod()) { $entityClassInput = null; } if (is_null($annotation->getOutput()) || is_array($annotation->getOutput())) { $entityClassOutput = $this->transformerHelper->getEntityClass($resource); } else { $entityClassOutput = $annotation->getOutput(); } if ('DELETE' === $annotation->getMethod()) { $entityClassInput = $entityClassOutput = null; } // input (populates 'parameters' for the formatters) if (null !== ($input = $entityClassInput)) { $normalizedInput = $this->normalizeClassParameter($input, $dunglasResource); $parameters = $this->getParametersParser($normalizedInput, $resource, $dunglasResource, $annotation); if ($hasFormtype && in_array($annotation->getMethod(), ['POST', 'PUT'])) { $parameters = $this->processFormParams($formName, $parameters, $dunglasResource); } $parameters = $this->clearClasses($parameters); $parameters = $this->generateHumanReadableTypes($parameters); if ($annotation->getMethod() === 'POST') { if (isset($parameters['id'])) { unset($parameters['id']); } } if (in_array($annotation->getMethod(), ['PUT', 'PATCH'])) { // All parameters are optional with PUT (update) array_walk($parameters, function ($val, $key) use(&$parameters) { $parameters[$key]['required'] = false; }); } $annotation->setParameters($parameters); } // output (populates 'response' for the formatters) if (null !== ($output = $entityClassOutput)) { $normalizedOutput = $this->normalizeClassParameter($output, $dunglasResource); if (!is_array($annotation->getOutput())) { $response = $this->getParametersParser($normalizedOutput, $resource, $dunglasResource, $annotation, 'Output'); foreach ($response as $key => $params) { if (isset($response[$key]['children'])) { unset($response[$key]['children']); } if ($response[$key]['actualType'] === 'model') { $response[$key]['dataType'] = 'Integer | ' . $response[$key]['dataType']; } } $response = $this->clearClasses($response); $response = $this->generateHumanReadableTypes($response); } else { $response = $this->normalizeArrayParameter($annotation->getOutput()); } $annotation->setResponse($response); $annotation->setResponseForStatusCode($response, $normalizedOutput, 200); } if (count($annotation->getResponseMap()) > 0) { foreach ($annotation->getResponseMap() as $code => $modelName) { if (is_array($modelName)) { continue; } if ('200' === (string) $code && isset($modelName['type']) && isset($modelName['model'])) { /* * Model was already parsed as the default `output` for this ApiDoc. */ continue; } $normalizedModel = $this->normalizeClassParameter($modelName, $dunglasResource); $parameters = array(); $supportedParsers = array(); foreach ($this->getParsers($normalizedModel) as $parser) { if ($parser->supports($normalizedModel)) { $supportedParsers[] = $parser; $parameters = $this->mergeParameters($parameters, $parser->parse($normalizedModel)); } } foreach ($supportedParsers as $parser) { if ($parser instanceof PostParserInterface) { $mp = $parser->postParse($normalizedModel, $parameters); $parameters = $this->mergeParameters($parameters, $mp); } } $parameters = $this->clearClasses($parameters); $parameters = $this->generateHumanReadableTypes($parameters); $annotation->setResponseForStatusCode($parameters, $normalizedModel, $code); } } return $annotation; }
/** * @param array $options * * @return Route */ protected function destroyRoute(array $options) { $route = new Route('/{id}/destroy'); $route->setMethods(['GET', 'POST']); $route->setDefault('_controller', $options['controller'] . ':destroy'); $route->setRequirement('id', '\\d+'); return $route; }
/** * @param $httpMethod * @param $path * @param $controller * @param array $params */ private function setMethod($httpMethod, $path, $controller, $requirements = []) { $params = []; if (!is_array($httpMethod)) { $httpMethod = [$httpMethod]; } list($controller, $method) = explode('::', $controller); $prefixedPath = $this->prefix . $path; $configsParams = array_merge(['_path' => $path, '_controller' => $controller, '_method' => $method], $params); if (is_array($this->middlewares) && count($this->middlewares) > 0) { $configsParams['_middleware'] = $this->middlewares; } $route = new Route($prefixedPath, $configsParams, $requirements); $route->setMethods($httpMethod); $this->routeColletion->add(implode('', $httpMethod) . $prefixedPath, $route); }
/** * @group legacy */ public function testLegacyMethodRequirement() { $this->iniSet('error_reporting', -1 & ~E_USER_DEPRECATED); $route = new Route('/'); $route->setRequirement('_method', 'GET|POST'); $this->assertEquals('GET|POST', $route->getRequirement('_method')); $this->assertEquals(array('GET', 'POST'), $route->getMethods()); $route->setMethods(array('gEt')); $this->assertEquals('GET', $route->getRequirement('_method')); $route->setMethods(array()); $this->assertNull($route->getRequirement('_method')); }
/** * Tests the altering of a REST route. */ public function testAlterRestRoute() { $collection = new RouteCollection(); $route = new Route('test_route', ['_controller' => 'Drupal\\Tests\\Core\\Controller\\TestController::content']); $route->setMethods(['POST']); $collection->add('test_route', $route); list($view) = $this->setupViewExecutableAccessPlugin(); $display = []; $display['display_plugin'] = 'page'; $display['id'] = 'page_1'; $display['display_options'] = ['path' => 'test_route']; $this->pathPlugin->initDisplay($view, $display); $this->pathPlugin->collectRoutes($collection); $view_route_names = $this->pathPlugin->alterRoutes($collection); $this->assertEquals([], $view_route_names); // Ensure that the test_route is not overridden. $this->assertCount(2, $collection); $route = $collection->get('test_route'); $this->assertTrue($route instanceof Route); $this->assertFalse($route->hasDefault('view_id')); $this->assertFalse($route->hasDefault('display_id')); $this->assertSame($collection->get('test_route'), $route); $route = $collection->get('view.test_id.page_1'); $this->assertTrue($route instanceof Route); $this->assertEquals('test_id', $route->getDefault('view_id')); $this->assertEquals('page_1', $route->getDefault('display_id')); $this->assertEquals('my views title', $route->getDefault('_title')); }
/** * @param BundleInterface $bundle * @param ClassMetadata $metadata * @param string $action * @return Route */ protected function createActionRoute(BundleInterface $bundle, ClassMetadata $metadata, $action, $methods = array('get')) { $route = new Route($this->getActionPath($bundle, $metadata, $action)); $route->setMethods($methods)->setDefaults(array('_controller' => $this->getControllerAction($bundle, $metadata, $action))); return $route; }
public function testHttpPostMethodRoute() { $route = new Route('/test1', array('controller' => 'MyController')); $route->setMethods(array('POST')); $routes = new RouteCollection(); $routes->add('route_name', $route); $request = WebRequest::create('/test1', 'POST', array('name' => 'Chris Noden')); $request->overrideGlobals(); $obj = new WebRouter($request); // Pass our route collection to our WebRouter object $obj->setRouteCollection($routes); // Match the request to the route $obj->match(); $controller = $obj->getController(); $this->assertEquals('MyController', $controller->getClassName()); // This GET request should fail $request = WebRequest::create('/test1', 'GET', array('name' => 'Chris Noden')); $request->overrideGlobals(); // Test for the exception // $this->setExpectedException( // 'Symfony\Component\Routing\Exception\MethodNotAllowedException', '' // ); $obj->match(); }
/** * Refresh the entity * * @ORM\PostLoad */ public function refreshEntity() { parent::setPath($this->path); parent::setDefaults($this->defaults); parent::setRequirements($this->requirements); parent::setOptions($this->options); parent::setHost($this->host); parent::setMethods($this->methods); parent::setSchemes($this->schemes); }
public function testMethodIsBC() { $route = new Route('/'); $route->setRequirement('_method', 'GET|POST'); $this->assertEquals('GET|POST', $route->getRequirement('_method')); $this->assertEquals(array('GET', 'POST'), $route->getMethods()); $route->setMethods(array('gEt')); $this->assertEquals('GET', $route->getRequirement('_method')); $route->setMethods(array()); $this->assertNull($route->getRequirement('_method')); }
/** * Get canonical route for schema requests * * @param string $service service id * @param array $serviceConfig service configuration * @param string $type service type (item or collection) * @param boolean $option render a options route * * @return Route */ public static function getCanonicalSchemaRoute($service, $serviceConfig, $type = 'item', $option = false) { $pattern = self::getBaseFromService($service, $serviceConfig); $pattern = '/schema' . $pattern . $type; $action = 'schemaAction'; $method = 'GET'; if ($option !== false) { $action = 'optionsAction'; $method = 'OPTIONS'; } $defaults = array('_controller' => $service . ':' . $action, '_format' => '~'); $route = new Route($pattern, $defaults, []); $route->setMethods($method); return $route; }