/**
* @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())];
}
