/** * @param Request $request * * @throws ServiceCircularReferenceException When a circular reference is detected * @throws ServiceNotFoundException When the service is not defined * * @return JsonResponse|Response */ public function searchAction(Request $request) { /* @var \Webburza\Sylius\LocationBundle\Doctrine\ORM\LocationRepository $locationRepository */ $locationRepository = $this->container->get('webburza_location.repository.location'); /* @var \Sylius\Component\Locale\Model\Locale */ $locale = $this->get('sylius.context.locale')->getCurrentLocale(); /* @var \Symfony\Component\Serializer\Serializer */ $serializer = $this->container->get('serializer'); if ($query = $request->get('query')) { $locations = $locationRepository->findPublicByQuery($query, $locale); } else { $locations = $locationRepository->findPublicByQuery('', $locale); } $locationsJson = $serializer->serialize($locations, 'json'); $returnJson = AcceptHeader::fromString($request->headers->get('Accept'))->has('application/json'); if ($returnJson) { $response = new JsonResponse($locationsJson); $response->headers->set('Access-Control-Allow-Origin', '*'); return $response; } else { $googleMapsKey = $this->getParameter('webburza.sylius.location_bundle.google_maps_key'); $googleMapsEnabled = $this->getParameter('webburza.sylius.location_bundle.google_maps_enabled'); return $this->render('WebburzaSyliusLocationBundle:Frontend:_search.html.twig', ['locations' => $locations, 'locationsJson' => $locationsJson, 'googleMapsEnabled' => $googleMapsEnabled, 'googleMapsKey' => $googleMapsKey]); } }
public function viewAction(Request $request) { $accept = AcceptHeader::fromString($request->headers->get('accept')); $finder = new Finder(); $userFiles = $finder->in(STORAGE_PATH)->name('*.json')->sortByModifiedTime()->files(); $users = function () use($userFiles) { foreach ($userFiles as $userFile) { /** @var SplFileInfo $userFile */ $data = json_decode($userFile->getContents(), true); $data['dob'] = new \DateTime($data['dob']['date']); $data['id'] = $userFile->getBasename('.json'); (yield $data); } }; $response = new Response(); if ($accept->has('text/html')) { $response->setContent($this->getTwig()->render('crud/view.html.twig', ['users' => $users(), 'urlGenerator' => $this->urlGenerator(), 'translator' => TranslationFactory::createTranslator($request), 'user' => $this->getUser()])); } elseif ($accept->has('application/json')) { $response = new Response('', Response::HTTP_OK, ['Content-Type' => 'application/json']); $userList = iterator_to_array($users()); $response->setContent(json_encode($userList)); } elseif ($accept->has('text/xml')) { $response = new Response('', Response::HTTP_OK, ['Content-Type' => 'text/xml']); $userList = iterator_to_array($users()); $xml = new \SimpleXMLElement('<root />'); array_walk($userList, function ($userData) use($xml) { $user = $xml->addChild('user'); $user->addChild('username', $userData['username']); }); $response->setContent($xml->asXML()); } return $response; }
/** * @param Request $request * @return bool */ protected function contentTypeHeaderValid(Request $request) { $contentTypeHeader = AcceptHeader::fromString($request->header('content-type')); if ($contentTypeHeader->has('application/vnd.api+json')) { $attributes = $contentTypeHeader->get('application/vnd.api+json')->getAttributes(); return empty($attributes) || count($attributes) === 1 && $contentTypeHeader->get('application/vnd.api+json')->getAttribute('charset') === 'UTF-8'; } return false; }
private function parseFormatFromHeader(Request $request, $headerName) { if (!$request->headers->has($headerName)) { //if there is no header with the specified name, fall-back on the default format return self::DEFAULT_FORMAT; } $acceptHeader = AcceptHeader::fromString($request->headers->get($headerName))->first(); $format = $acceptHeader->getAttribute('format', null); return is_null($format) ? self::DEFAULT_FORMAT : $format; }
/** * @param GetResponseEvent $event * @return null */ public function onRequest(GetResponseEvent $event) { if (!$event->isMasterRequest()) { return null; } $accept = AcceptHeader::fromString($event->getRequest()->headers->get('Accept')); if ($accept->has('*/*') || $accept->has('application/json')) { return null; } $event->setResponse($this->responseToSend); }
/** * @param Request $request * @param $version * @return mixed */ public function getVersionByAcceptHeaders(Request $request, $version) { $acceptHeader = AcceptHeader::fromString($request->headers->get('Accept'))->all(); foreach ($acceptHeader as $acceptHeaderItem) { if ($acceptHeaderItem->hasAttribute('version')) { $version = $acceptHeaderItem->getAttribute('version'); break; } } return $version; }
/** * Returns the API version. * * @return int $version * The version number of the API (default: 1). * */ public function getVersion() { $version = 1; $accept = AcceptHeader::fromString($this->headers->get('accept')); // We'll assume the first accept header to have a version is accurate. foreach ($accept->all() as $item) { if ($item->getAttribute('version')) { $version = $item->getAttribute('version'); break; } } return $version; }
/** * @param Request $request * * @return mixed|string */ public function getContext(Request $request = null) { $context = 'ld-json'; if (null !== $request) { $acceptHeader = AcceptHeader::fromString($request->headers->get('Accept'))->all(); foreach ($acceptHeader as $acceptHeaderItem) { if ($acceptHeaderItem->hasAttribute('version')) { $context = str_ireplace('application/', '', $acceptHeaderItem->getValue()); break; } } } return $context; }
/** * parse Accept-Language header from request. * * @param GetResponseEvent $event listener event * * @return void */ public function onKernelRequest(GetResponseEvent $event) { $request = $event->getRequest(); $headers = AcceptHeader::fromString($request->headers->get('Accept-Language')); $languages = array_intersect(array_map(function ($header) { return $header->getValue(); }, $headers->all()), array_map(function ($language) { return $language->getId(); }, $this->repository->findAll())); if (empty($languages)) { $languages[$this->defaultLocale] = $this->defaultLocale; } $request->attributes->set('languages', $languages); }
/** * @param Request $request * * @return mixed|string */ public function getVersion(Request $request = null) { $version = 'v2'; if ($request instanceof Request) { $acceptHeader = AcceptHeader::fromString($request->headers->get('Accept'))->all(); foreach ($acceptHeader as $acceptHeaderItem) { if ($acceptHeaderItem->hasAttribute('version')) { $version = $acceptHeaderItem->getAttribute('version'); break; } } } return $version; }
/** * Check the content-type header. * * @param string $content * @return boolean */ public function checkContentTypeHeader($content) { $header = AcceptHeader::fromString($content); if (!$header->has(self::CONTENT_TYPE)) { throw new InvalidJsonApiContentTypeHeader(); } $attributes = $header->get(self::CONTENT_TYPE)->getAttributes(); if (count($attributes) > 1) { throw new InvalidJsonApiContentTypeHeaderParameterCount(); } if (count($attributes) === 1 && $header->get(self::CONTENT_TYPE)->getAttribute('charset') !== 'UTF-8') { throw new InvalidJsonApiContentTypeHeaderCharset(); } return true; }
private function getVersion(Request $request, $headerName) { if (!$request->headers->has($headerName)) { return null; } $acceptHeader = AcceptHeader::fromString($request->headers->get($headerName))->first(); $version = $acceptHeader->getAttribute('version', null); if (!is_null($version)) { if (!ctype_digit((string) $version)) { throw new UnsupportedVersionException(sprintf('Version %s is invalid', $version), UnsupportedVersionException::CODE); } return (int) $version; } return null; }
/** * Detect the request format based on the priorities and the Accept header * * Note: Request "_format" parameter is considered the preferred Accept header * * @param Request $request The request * @param array $priorities Ordered array of formats (highest priority first) * @param Boolean $preferExtension If to consider the extension last or first * * @return void|string The format string */ public function getBestFormat(Request $request, array $priorities, $preferExtension = false) { // BC - Maintain this while 2.0 and 2.1 dont reach their end of life // Note: Request::splitHttpAcceptHeader is deprecated since version 2.2, to be removed in 2.3. if (class_exists('Symfony\\Component\\HttpFoundation\\AcceptHeader')) { $mimetypes = array(); foreach (AcceptHeader::fromString($request->headers->get('Accept'))->all() as $item) { $mimetypes[$item->getValue()] = $item->getQuality(); } } else { $mimetypes = $request->splitHttpAcceptHeader($request->headers->get('Accept')); } $extension = $request->get('_format'); if (null !== $extension && $request->getMimeType($extension)) { $mimetypes[$request->getMimeType($extension)] = $preferExtension ? reset($mimetypes) + 1 : end($mimetypes) - 1; arsort($mimetypes); } if (empty($mimetypes)) { return null; } $catchAllEnabled = in_array('*/*', $priorities); return $this->getFormatByPriorities($request, $mimetypes, $priorities, $catchAllEnabled); }
/** * Gets a list of content types acceptable by the client browser. * * @return array List of content types in preferable order * * @api */ public function getAcceptableContentTypes() { if (null !== $this->acceptableContentTypes) { return $this->acceptableContentTypes; } return $this->acceptableContentTypes = array_keys(AcceptHeader::fromString($this->headers->get('Accept'))->all()); }
/** * @return array */ public function getAcceptedLocales() { if (!$this->acceptLanguageHeader) { return []; } return array_keys(AcceptHeader::fromString($this->acceptLanguageHeader)->all()); }
/** * Splits an Accept-* HTTP header. * * @param string $header Header to split * * @return array Array indexed by the values of the Accept-* header in preferred order * * @deprecated Deprecated since version 2.2, to be removed in 2.3. */ public function splitHttpAcceptHeader($header) { $headers = array(); foreach (AcceptHeader::fromString($header)->all() as $item) { $key = $item->getValue(); foreach ($item->getAttributes() as $name => $value) { $key .= sprintf(';%s=%s', $name, $value); } $headers[$key] = $item->getQuality(); } return $headers; }
/** * Returns Accept-Language header from headers. * * @param Headers $headers * * @return string */ protected function getAcceptLanguageHeader(Headers $headers) { $header = $headers->get('Accept-Language'); if ($header === false) { return ''; } elseif (!$header instanceof \ArrayIterator) { $header = new \ArrayIterator([$header]); } $items = []; $header->rewind(); while ($header->valid()) { $items[] = AcceptHeaderItem::fromString($header->current()->getFieldValue()); $header->next(); } $acceptHeader = new AcceptHeader($items); return $acceptHeader->__toString(); }
/** * Perform content negotiation by looking the the current URL and the Accept request header * * @param EventInterface $event The event instance */ public function negotiate(EventInterface $event) { $request = $event->getRequest(); $response = $event->getResponse(); $formatter = null; $extension = $request->getExtension(); $routeName = (string) $request->getRoute(); $config = $event->getConfig(); $contentNegotiateImages = $config['contentNegotiateImages']; $model = $response->getModel(); if (!$extension && !$contentNegotiateImages && $model instanceof Model\Image) { // Configuration is telling us not to use content negotiation for images, // instead we want to use the original format of the image $mime = $model->getMimeType(); $formatter = $this->supportedTypes[$mime]; } else { if ($extension && !($model instanceof Model\Error && $routeName === 'image')) { // The user agent wants a specific type. Skip content negotiation completely, but not // if the request is against the image resource, and ended up as an error, because then // Imbo would try to render the error as an image. $mime = $this->defaultMimeType; if (isset($this->extensionsToMimeType[$extension])) { $mime = $this->extensionsToMimeType[$extension]; } $formatter = $this->supportedTypes[$mime]; } else { // Set Vary to Accept since we are doing content negotiation based on Accept $response->setVary('Accept', false); // No extension have been provided $acceptableTypes = array(); foreach (AcceptHeader::fromString($request->headers->get('Accept', '*/*'))->all() as $item) { $acceptableTypes[$item->getValue()] = $item->getQuality(); } $match = false; $maxQ = 0; // Specify which types to check for since all models can't be formatted by all // formatters $modelClass = get_class($model); $modelType = strtolower(substr($modelClass, strrpos($modelClass, '\\') + 1)); $types = $this->defaultModelTypes; if (isset($this->modelTypes[$modelType])) { $types = $this->modelTypes[$modelType]; } // If we are dealing with images we want to make sure the original mime type of the // image is checked first. If the client does not really have any preference with // regards to the mime type (*/* or image/*) this results in the original mime type of // the image being sent. if ($model instanceof Model\Image) { $original = $model->getMimeType(); if ($types[0] !== $original) { $types = array_filter($types, function ($type) use($original) { return $type !== $original; }); array_unshift($types, $original); } } foreach ($types as $mime) { if (($q = $this->contentNegotiation->isAcceptable($mime, $acceptableTypes)) && $q > $maxQ) { $maxQ = $q; $match = true; $formatter = $this->supportedTypes[$mime]; } } if (!$match && !$event->hasArgument('noStrict')) { // No types matched with strict mode enabled. The client does not want any of Imbo's // supported types. Y U NO ACCEPT MY TYPES?! FFFFUUUUUUU! throw new Exception\RuntimeException('Not acceptable', 406); } else { if (!$match) { // There was no match but we don't want to be an ass about it. Send a response // anyway (allowed according to RFC2616, section 10.4.7) $formatter = $this->supportedTypes[$this->defaultMimeType]; } } } } $this->formatter = $formatter; }
/** * Splits an Accept-* HTTP header. * * @param string $header Header to split * * @return array Array indexed by the values of the Accept-* header in preferred order * * @deprecated Deprecated since version 2.2, to be removed in 2.3. */ public function splitHttpAcceptHeader($header) { trigger_error('splitHttpAcceptHeader() is deprecated since version 2.2 and will be removed in 2.3.', E_USER_DEPRECATED); $headers = array(); foreach (AcceptHeader::fromString($header)->all() as $item) { $key = $item->getValue(); foreach ($item->getAttributes() as $name => $value) { $key .= sprintf(';%s=%s', $name, $value); } $headers[$key] = $item->getQuality(); } return $headers; }
/** * @dataProvider provideSortingData */ public function testSorting($string, array $values) { $header = AcceptHeader::fromString($string); $this->assertEquals($values, array_keys($header->all())); }