/**
* {@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;
}
