/** * @param ServerRequestInterface $request * @param RouterInterface $router */ public function __construct(ServerRequestInterface $request, RouterInterface $router) { $this->request = $request; parent::__construct($this); $this->parameters = $this->parseIncomingParams(); $this->parameters = array_merge($this->parameters, $this->request->getParsedBody(), $this->getParsedAttributes($request, $router), $this->getQueryParams(), $this->request->getUploadedFiles()); $this->parsedBody = array_merge(parent::getParsedBody(), $this->parameters); }
/** * {@inheritdoc} */ public function data(ServerRequestInterface $request, Document $document) { $this->assertAdmin($request->getAttribute('actor')); $file = array_get($request->getUploadedFiles(), 'favicon'); $tmpFile = tempnam($this->app->storagePath() . '/tmp', 'favicon'); $file->moveTo($tmpFile); $extension = pathinfo($file->getClientFilename(), PATHINFO_EXTENSION); if ($extension !== 'ico') { $manager = new ImageManager(); $encodedImage = $manager->make($tmpFile)->resize(64, 64, function ($constraint) { $constraint->aspectRatio(); $constraint->upsize(); })->encode('png'); file_put_contents($tmpFile, $encodedImage); $extension = 'png'; } $mount = new MountManager(['source' => new Filesystem(new Local(pathinfo($tmpFile, PATHINFO_DIRNAME))), 'target' => new Filesystem(new Local($this->app->publicPath() . '/assets'))]); if (($path = $this->settings->get('favicon_path')) && $mount->has($file = "target://{$path}")) { $mount->delete($file); } $uploadName = 'favicon-' . Str::lower(Str::quickRandom(8)) . '.' . $extension; $mount->move('source://' . pathinfo($tmpFile, PATHINFO_BASENAME), "target://{$uploadName}"); $this->settings->set('favicon_path', $uploadName); return parent::data($request, $document); }
/** * {@inheritdoc} */ protected function data(ServerRequestInterface $request, Document $document) { $id = array_get($request->getQueryParams(), 'id'); $actor = $request->getAttribute('actor'); $file = array_get($request->getUploadedFiles(), 'avatar'); return $this->bus->dispatch(new UploadAvatar($id, $file, $actor)); }
private function _extractDataPSR7(ServerRequestInterface $request = null, $name = '') { $method = $request->getMethod(); $queryParams = $request->getQueryParams(); if ('GET' === $method) { if ('' === $name) { return $queryParams; } // Don't submit GET requests if the form's name does not exist // in the request if (!isset($queryParams[$name])) { return; } return $queryParams[$name]; } $serverParams = $request->getServerParams(); $uploadedFiles = $request->getUploadedFiles(); if ('' === $name) { return $this->mergeParamsAndUploadedFiles($serverParams, $uploadedFiles); } if (isset($serverParams[$name]) || isset($uploadedFiles[$name])) { $default = null; $params = isset($serverParams[$name]) ? $serverParams[$name] : null; $files = isset($uploadedFiles[$name]) ? $uploadedFiles[$name] : null; return $this->mergeParamsAndUploadedFiles($params, $files); } // Don't submit the form if it is not present in the request return; }
/** * Converts a PSR-7 request into an OAuth2 request. * * @param ServerRequestInterface $psrRequest * @return Request */ public static function convertRequestFromPsr7(ServerRequestInterface $psrRequest) { $headers = []; foreach ($psrRequest->getHeaders() as $header => $value) { $headers[$header] = implode(';', $value); } return new Request($psrRequest->getQueryParams(), is_array($psrRequest->getParsedBody()) ? $psrRequest->getParsedBody() : [], $psrRequest->getAttributes(), $psrRequest->getCookieParams(), self::getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString(), $headers); }
/** * Assign form values from request */ protected function updateValuesFromRequest() { $data = $this->getRequest()->isPost() ? $this->getRequest()->getPost() : $this->getRequest()->getQuery(); if (isset($_FILES)) { $data = array_merge($data, $this->request->getUploadedFiles()); } $this->setValues($data); }
/** * {@inheritdoc} */ public function createRequest(ServerRequestInterface $psrRequest) { $parsedBody = $psrRequest->getParsedBody(); $parsedBody = is_array($parsedBody) ? $parsedBody : array(); $request = new Request($psrRequest->getQueryParams(), $parsedBody, $psrRequest->getAttributes(), $psrRequest->getCookieParams(), $this->getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString()); $request->headers->replace($psrRequest->getHeaders()); return $request; }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @return ResponseInterface */ public function onPost(ServerRequestInterface $request, ResponseInterface $response) { /** @var UploadedFile $upload */ $uploaded = $request->getUploadedFiles(); $upload = $uploaded['up'][0]; $viewData = $this->responder->getViewData()->setData('isUploaded', true)->setData('dump', print_r($uploaded, true))->setData('upload', $upload)->setData('error_code', $upload->getError()); return $this->viewer->__invoke($request, $response, $viewData); // callable }
/** * Convert a PSR-7 ServerRequest to a Zend\Http server-side request. * * @param ServerRequestInterface $psr7Request * @param bool $shallow Whether or not to convert without body/file * parameters; defaults to false, meaning a fully populated request * is returned. * @return Zend\Request */ public static function toZend(ServerRequestInterface $psr7Request, $shallow = false) { if ($shallow) { return new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), [], [], $psr7Request->getServerParams()); } $zendRequest = new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), $psr7Request->getParsedBody() ?: [], self::convertUploadedFiles($psr7Request->getUploadedFiles()), $psr7Request->getServerParams()); $zendRequest->setContent($psr7Request->getBody()); return $zendRequest; }
protected function resolveSources(ServerRequestInterface $request) { $original_data = ['get' => $request->getQueryParams(), 'post' => $request->getParsedBody(), 'file' => $request->getUploadedFiles(), 'cookie' => $request->getCookieParams(), 'uri' => $this->resolveUriSource($request)]; foreach ($this->param_sources as $item => $source) { if (isset($original_data[$source][$item])) { $params[$item] = $original_data[$source][$item]; } } return $params; }
public function isUpload(ServerRequestInterface $request) { $contentTypes = $request->getHeader('Content-Type'); foreach ($contentTypes as $contentType) { if (false !== strpos($contentType, 'multipart/form-data')) { return count($request->getUploadedFiles()) > 0; } } return false; }
/** * Load the form values from a PSR-7 ServerRequest. * * @param ServerRequestInterface $request * * @return self */ public function loadFromPsr7(ServerRequestInterface $request) { if (strtolower($this->attr('method')) === 'post') { $values = $request->getParsedBody(); $files = $request->getUploadedFiles(); $values = array_replace_recursive($values, $files); } else { $values = $request->getQueryParams(); } return $this->load($values); }
public function it_can_parse_a_HttpRequest(ServerRequestInterface $httpRequest, UploadedFileInterface $file) { $path = '/path/To/a'; $attributes = ['path' => $path]; $files = [$file]; $httpRequest->getUploadedFiles()->willReturn($files); $httpRequest->getHeaderLine('Accept')->willReturn('application/json'); $request = $this->parseHttpRequest($httpRequest, $attributes); $request->shouldHaveType(RequestInterface::class); $request->getRequestName()->shouldReturn(UploadFileHandler::MESSAGE); $request['path']->shouldBe($attributes['path']); }
public function parseHttpRequest(ServerHttpRequest $httpRequest, array $attributes) : RequestInterface { $rpHelper = new HttpRequestParserHelper($httpRequest); $this->helper->addPathFilter($rpHelper->getFilter(), 'path'); $validator = $rpHelper->getValidator(); $this->helper->addPathValidator($validator, 'path'); $validator->required('files')->callback(function ($array) { return is_array($array) && count($array) > 0; }); $data = ['path' => $attributes['path'], 'files' => $httpRequest->getUploadedFiles()]; return new Request(self::MESSAGE, $rpHelper->filterAndValidate($data), $httpRequest); }
/** * Construct action request. * * @param \Psr\Http\Message\ServerRequestInterface $request Request to wrap. */ public function __construct(\Psr\Http\Message\ServerRequestInterface $request) { parent::__construct($request->getBody()); foreach ($request->getHeaders() as $name => $value) { $this->setHeader($name, $value); } $this->protocolVersion = $request->getProtocolVersion(); $this->method = $request->getMethod(); $this->requestTarget = $request->getRequestTarget(); $this->uri = $request->getUri(); $this->attributes = $request->getAttributes(); $this->cookies = $request->getCookieParams(); $this->data = $request->getParsedBody(); $this->query = $request->getQueryParams(); $this->server = $request->getServerParams(); $this->files = $request->getUploadedFiles(); if (isset($this->server['SCRIPT_NAME'])) { $this->attributes['basePath'] = dirname($this->server['SCRIPT_NAME']); $this->attributes['scriptName'] = basename($this->server['SCRIPT_NAME']); } else { $this->attributes['basePath'] = '/'; $this->attributes['scriptName'] = 'index.php'; } if (!isset($this->attributes['path'])) { $this->attributes['path'] = self::findPath($this); } if (!isset($this->attributes['rewrite'])) { $this->attributes['rewrite'] = false; } if (!isset($this->attributes['accepts'])) { $this->attributes['accepts'] = []; if (isset($this->server['HTTP_ACCEPT'])) { $contentTypes = explode(',', $this->server['HTTP_ACCEPT']); foreach ($contentTypes as $contentType) { $contentType = explode(';', $contentType); $this->attributes['accepts'][] = trim(strtolower($contentType[0])); } } } if (!isset($this->attributes['encodings'])) { $this->attributes['encodings'] = []; if (isset($this->server['HTTP_ACCEPT_ENCODING'])) { $acceptEncodings = explode(',', $this->server['HTTP_ACCEPT_ENCODING']); foreach ($acceptEncodings as $encoding) { $this->attributes['encodings'][] = trim(strtolower($encoding)); } } } }
/** * Flatten all input from the request * * @param ServerRequestInterface $request * * @return array */ public function __invoke(ServerRequestInterface $request) { $attrs = $request->getAttributes(); $body = $request->getParsedBody(); $cookies = $request->getCookieParams(); $query = $request->getQueryParams(); $uploads = $request->getUploadedFiles(); if (empty($body)) { $body = []; } elseif (is_object($body)) { // Because the parsed body may also be represented as an object, // additional parsing is required. This is a bit dirty but works // very well for anonymous objects. $body = json_decode(json_encode($body), true); } // Order matters here! Important values go last! return array_replace($query, $body, $uploads, $cookies, $attrs); }
/** * {@inheritdoc} */ public function createRequest(ServerRequestInterface $psrRequest) { $server = array(); $uri = $psrRequest->getUri(); if ($uri instanceof UriInterface) { $server['SERVER_NAME'] = $uri->getHost(); $server['SERVER_PORT'] = $uri->getPort(); $server['REQUEST_URI'] = $uri->getPath(); $server['QUERY_STRING'] = $uri->getQuery(); } $server['REQUEST_METHOD'] = $psrRequest->getMethod(); $server = array_replace($server, $psrRequest->getServerParams()); $parsedBody = $psrRequest->getParsedBody(); $parsedBody = is_array($parsedBody) ? $parsedBody : array(); $request = new Request($psrRequest->getQueryParams(), $parsedBody, $psrRequest->getAttributes(), $psrRequest->getCookieParams(), $this->getFiles($psrRequest->getUploadedFiles()), $server, $psrRequest->getBody()->__toString()); $request->headers->replace($psrRequest->getHeaders()); return $request; }
/** * Get filtered parameters of the request. * * @param int $mode * * @return array */ protected function getFilteredParams($mode = 0) { if ($this->filteredParams) { return $this->filteredParams; } $this->filteredParams = array(); switch ($mode) { case 1: $params = $this->getQueryParams(); break; case 2: $params = $this->getBodyParams(); break; default: $params = $this->getParams(); } $uploadedFiles = $this->request->getUploadedFiles(); //error_log('[getFilteredParams]'.$mode. '#####' . var_export($params, true)); if (is_array($params) && $this->inputs) { foreach ($this->inputs as $key => $input) { $type = isset($input['type']) && $input['type'] ? $input['type'] : 'String'; if ($type === 'file') { $value = isset($uploadedFiles[$key]) ? $uploadedFiles[$key] : null; } else { $value = isset($params[$key]) ? $params[$key] : null; } $className = '\\Unicorn\\Inputs\\' . ucfirst(strtolower($type)) . 'Input'; if (class_exists($className)) { $class = new $className($key, $value, $input); $valid = $class->validate(); if ($valid === Input::VALID_CODE_SUCCESS) { $this->filteredParams[$key] = $class->getValidValue(); } else { error_log('[getFilteredParams] Invalid input ' . $key . ' validation code: ' . $valid); $this->invalid[] = array('name' => $key, 'value' => $value, 'code' => $valid); } } else { error_log('[WARNING] Input class not found: ' . $className); } } } return $this->filteredParams; }
public function __invoke(ServerRequestInterface $request) { $input = []; if ($params = $request->getQueryParams()) { $input = array_replace($input, $params); } if ($params = $request->getParsedBody()) { $input = array_replace($input, $params); } if ($params = $request->getUploadedFiles()) { $input = array_replace($input, $params); } if ($params = $request->getCookieParams()) { $input = array_replace($input, $params); } if ($params = $request->getAttributes()) { $input = array_replace($input, $params); } return $input; }
function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { if ($request->getMethod() != 'POST') { return $response->withStatus(405); } // Method not allowed $files = $request->getUploadedFiles(); if ($files) { try { /** @var UploadedFileInterface $file */ $file = array_pop($files); $fileRec = new File(); $params = $request->getQueryParams(); $fileRec->owner_id = get($params, 'owner_id'); $fileRec->owner_type = get($params, 'owner_type'); $ownerType = last(explode('\\', $fileRec->owner_type)); $uid = uniqid(); $name = $file->getClientFilename(); $l = explode('.', $name); $ext = strtolower(array_pop($l)); $fileRec->name = implode('.', $l); $fileRec->path = self::SOURCE_PATH . "/{$ownerType}/{$fileRec->owner_id}/{$uid}.{$ext}"; $fileRec->image = $ext == 'jpg' || $ext == 'png' || $ext == 'gif' || $ext == 'tiff'; $fileRec->id = $uid; $fileRec->ext = $ext; $base = $this->kernelSettings->baseDirectory . '/'; $path = $base . dirname($fileRec->path); @mkdir($path, 0777, true); $file->moveTo($base . $fileRec->path); $fileRec->save(); $response->getBody()->write($fileRec->path); return $response; } catch (\Exception $e) { echo $e->__toString(); exit(500); } } return $response->withStatus(400); // Bad request }
public function run(ServerRequestInterface $request, ResponseBuilder $responseBuilder) : ResponseInterface { try { /** @var UploadedFile $file */ $file = $request->getUploadedFiles()["file"]; $filename = $file->getClientFilename(); if (!strlen($filename)) { $filename = GenerateRandomString::gen(self::AUTO_GENERATE_FILE_NAME_LENGTH); } if ($file->getError() !== 0) { throw new FileNotUploadedException('Failed to upload file'); } $entity = $this->attachmentService->uploadAttachment($file->getStream()->getMetadata('uri'), $filename); $responseBuilder->setStatusSuccess()->setJson(['entity' => $entity->toJSON()]); } catch (FileTooBigException $e) { $responseBuilder->setStatus(409)->setError($e); } catch (FileTooSmallException $e) { $responseBuilder->setStatus(409)->setError($e); } catch (AttachmentFactoryException $e) { $responseBuilder->setStatusBadRequest()->setError($e); } return $responseBuilder->build(); }
/** * {@inheritdoc} */ public function getUploadedFiles() { return $this->wrapped->getUploadedFiles(); }
/** * @param ServerRequestInterface $request * @return ResponseInterface */ public function update(ServerRequestInterface $request) { $validator = new Validator(['title' => [Validator::required(), Validator::length(1, 100)], 'category' => [Validator::required()]]); if (!$validator->validate($request->getParsedBody())) { return Response::factory(400, $validator->getErrorMessage()); } $title = Input::fromBody('title'); $category = Input::fromBody('category'); $contents = Input::fromBody('contents'); $url = Input::fromBody('url'); $link = Input::fromBody('link'); $filter = Input::fromBody('filter'); $facebook = Input::fromBody('facebook'); $master = Input::fromBody('master'); $address = Input::fromBody('address'); $phone = Input::fromBody('phone'); $time = Input::fromBody('time'); $seat = Input::fromBody('seat'); $parking = Input::fromBody('parking'); $lat = Input::fromBody('lat'); $lng = Input::fromBody('lng'); $event = Input::fromBody('event'); $eventTitle = Input::fromBody('eventTitle'); $eventContents = Input::fromBody('eventContents'); $eventLink = Input::fromBody('eventLink'); $valuesToUpdate = ['title' => $title, 'category_id' => $category, 'contents' => $contents, 'extra' => ['url' => $url, 'link' => $link, 'store' => ['filter' => $filter, 'facebook' => $facebook, 'master' => $master, 'address' => $address, 'phone' => $phone, 'time' => $time, 'seat' => $seat, 'parking' => $parking, 'lat' => $lat, 'lng' => $lng, 'event' => $event], 'event' => ['eventTitle' => $eventTitle, 'eventContents' => $eventContents, 'eventLink' => $eventLink]]]; $files = $request->getUploadedFiles(); $post = $this->repository->get($request->getAttribute('id')); $valuesToUpdate['thumbnail'] = $this->fileParser($files['thumbnail']); if (!isset($valuesToUpdate['thumbnail'])) { $valuesToUpdate['thumbnail'] = isset($post['thumbnail']) ? $post['thumbnail'] : ''; if (Input::fromBody('thumbnailDelete') === '1') { $valuesToUpdate['thumbnail'] = ''; } } for ($i = 0; $i < 4; $i++) { $file = $this->fileParser($files['eventImage' . $i]); if (isset($file)) { $valuesToUpdate['extra']['event']['eventImage'][$i] = $file; } else { $valuesToUpdate['extra']['event']['eventImage'][$i] = isset($post['extra']['event']['eventImage'][$i]) ? $post['extra']['event']['eventImage'][$i] : ''; if (Input::fromBody('eventImageDelete' . $i) === '1') { $valuesToUpdate['extra']['event']['eventImage'][$i] = ''; } } } $this->repository->where(['id' => $request->getAttribute('id')])->update($valuesToUpdate); return Response::redirect('/admin/posts'); }
/** * {@inheritDoc} */ public function getUploadedFiles() { return $this->psrRequest->getUploadedFiles(); }
/** * Returns a new instance of \OAuth2\Request based on the given \Slim\Http\Request * * @param ServerRequestInterface $request The psr-7 request. * * @return OAuth2\Request */ public static final function toOAuth2(ServerRequestInterface $request) { return new OAuth2\Request((array) $request->getQueryParams(), (array) $request->getParsedBody(), $request->getAttributes(), $request->getCookieParams(), self::convertUploadedFiles($request->getUploadedFiles()), $request->getServerParams(), (string) $request->getBody(), self::cleanupHeaders($request->getHeaders())); }
/** * List of media files * * @param Request $request * @param Response $response * @return Response */ public function media(Request $request, Response $response) { $data = []; $files = []; $path = $this->settings['presentation']['media']; $file = new File($path, '/', 'png|jpg|jpeg|bmp|gif|svg'); if ($_POST) { $form = new Form($path); $inpFile = $request->getUploadedFiles()['file']; if ($form->uploadMedia($inpFile) === true) { $data['flash'] = ['message' => 'Media uploaded successfully.', 'alert_type' => 'success']; } else { $data['flash'] = ['message' => 'Error! while uploading media.', 'alert_type' => 'danger']; } } if ($file->ls() === false) { $data['flash'] = ['message' => $file->getMessage(), 'alert_type' => 'danger']; } else { $files = $file->getFiles(); } $data['files'] = $files; $data['csrf_name'] = $request->getAttribute('csrf_name'); $data['csrf_value'] = $request->getAttribute('csrf_value'); $data['active_page'] = 'media'; return $this->view->render($response, 'admin/media.twig', $data); }
protected function runMatches(ServerRequestInterface $request) { $files = $request->getUploadedFiles(); return isset($files[$this->expected]); }
/** * Extract the uploaded files out of the request object. * * CakePHP expects to get arrays of file information and * not the parsed objects that PSR7 requests contain. Downsample the data here. * * @param \Psr\Http\Message\ServerRequestInterface $request The request to extract files from. * @return array The routing parameters. */ protected static function getFiles($request) { return static::convertFiles([], $request->getUploadedFiles()); }
/** * Stores the uploaded file and returns the path to this file * * @param \Psr\Http\Message\ServerRequestInterface $request PSR-7 request object * @param string $clientFilename Result parameter for the file name sent by the client * @throws \Aimeos\Controller\ExtJS\Exception If no file was uploaded or an error occured * @return string Path to the stored file */ protected function storeFile(\Psr\Http\Message\ServerRequestInterface $request, &$clientFilename = '') { $context = $this->getContext(); $files = (array) $request->getUploadedFiles(); if (($file = reset($files)) === false || $file->getError() !== UPLOAD_ERR_OK) { throw new \Aimeos\Controller\ExtJS\Exception('No file was uploaded or an error occured'); } $clientFilename = $file->getClientFilename(); $fileext = pathinfo($clientFilename, PATHINFO_EXTENSION); $dest = md5($clientFilename . time() . getmypid()) . '.' . $fileext; $fs = $context->getFilesystemManager()->get('fs-admin'); $fs->writes($dest, $file->getStream()->detach()); return $dest; }
public function __invoke(ServerRequestInterface $request) { return [array_merge((array) $request->getQueryParams(), (array) $request->getAttributes(), (array) $request->getParsedBody(), (array) $request->getUploadedFiles())]; }