/** * @ORM\PreFlush() */ public function preUpload() { if ($this->file) { if ($this->file instanceof FileUpload) { $basename = $this->file->getSanitizedName(); $basename = $this->suggestName($this->getFilePath(), $basename); $this->setName($basename); } else { $basename = trim(Strings::webalize($this->file->getBasename(), '.', FALSE), '.-'); $basename = $this->suggestName(dirname($this->file->getPathname()), $basename); $this->setName($basename); } if ($this->_oldPath && $this->_oldPath !== $this->path) { @unlink($this->getFilePathBy($this->_oldProtected, $this->_oldPath)); } if ($this->file instanceof FileUpload) { $this->file->move($this->getFilePath()); } else { copy($this->file->getPathname(), $this->getFilePath()); } return $this->file = NULL; } if (($this->_oldPath || $this->_oldProtected !== NULL) && ($this->_oldPath != $this->path || $this->_oldProtected != $this->protected)) { $oldFilePath = $this->getFilePathBy($this->_oldProtected !== NULL ? $this->_oldProtected : $this->protected, $this->_oldPath ?: $this->path); if (file_exists($oldFilePath)) { rename($oldFilePath, $this->getFilePath()); } } }
public function create(Product $product, FileUpload $fileUpload) { switch ($fileUpload->getContentType()) { case 'image/jpeg': $suffix = 'jpg'; break; case 'image/png': $suffix = 'png'; break; case 'image/gif': $suffix = 'gif'; break; default: throw new EntityInvalidArgumentException(sprintf('File is of an unknown type %s.', $fileUpload->getContentType())); } $baseName = sprintf('%s-%%s.%s', Strings::webalize($product->getName()), $suffix); do { $fileName = sprintf($baseName, Random::generate(5, '0-9a-zA-Z')); $path = sprintf('%s/%s', $this->imagesDir, $fileName); } while (file_exists($path)); $fileUpload->move($path); $image = new ProductImage($product, $fileName); $this->createEntity($image); $product->addImage($image); return $image; }
/** * @param Nette\Http\FileUpload $file * @param string $path * @param array $enabledExt * @return bool */ protected function saveFile($file, $path, $enabledExt = array('jpg', 'jpeg')) { if ($file->error) { return false; } $filename = $file->getName(); if (!in_array(self::getExtensionByName($filename), $enabledExt)) { return false; } try { $src = imagecreatefromjpeg($file->getTemporaryFile()); list($width, $height) = getimagesize($file->getTemporaryFile()); $aspectRatio = $width / $height; if ($aspectRatio > 1) { $targetWidth = self::MAX_DIMENSION; $targetHeight = round(self::MAX_DIMENSION / $aspectRatio); } else { $targetWidth = round(self::MAX_DIMENSION * $aspectRatio); $targetHeight = self::MAX_DIMENSION; } $bigThumbnail = imagecreatetruecolor($targetWidth, $targetHeight); imagecopyresampled($bigThumbnail, $src, 0, 0, 0, 0, $targetWidth, $targetHeight, $width, $height); imagejpeg($bigThumbnail, self::SAVE_DIR . $path, 75); } catch (\Exception $e) { return false; } return true; }
/** * @param FileUpload|NULL $file * @param string $folder * * @return array|bool */ protected function saveImage(FileUpload $file = NULL, $folder = '') { if ($this->mainManager instanceof MagicManager) { $folder = $this->mainManager->getImageFolder(); } else { if ($folder == '') { $folder = 'misc'; } } // Main image $image = NULL; if (isset($file) && $file->isOk()) { // Save ... $year = date('Y'); $month = date('m'); $namespace = "{$folder}/{$year}/{$month}"; $this->imageStorage->setNamespace($namespace); $image = $this->imageStorage->save($file->getContents(), $file->getName()); $filename = pathinfo($image->getFile(), PATHINFO_BASENAME); // Prepare thumbnail $this->imgPipe->setNamespace($namespace); $this->imgPipe->request($filename, '200x200', 'exact'); $this->imgPipe->setNamespace($namespace); $this->imgPipe->request($filename, '100x100', 'exact'); $data = ['namespace' => $namespace, 'filename' => $filename]; return $data; } else { return FALSE; } }
/** * @param FileUpload $file * @return Image * @throws NotImageUploadedException * @throws FileSizeException * @throws DBALException * @throws InvalidStateException */ public function processImage(FileUpload $file) { if (!$file->isImage()) { throw new NotImageUploadedException(); } if (\filesize($file->getTemporaryFile()) > Image::MAX_FILE_SIZE) { throw new FileSizeException(); } try { $this->em->beginTransaction(); $image = new Image($file); $this->em->persist($image)->flush(); $file->move($this->composeImageLocation($image)); $this->em->commit(); } catch (InvalidStateException $is) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Error occurs while moving temp. image file to new location.'); throw $is; } catch (DBALException $e) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Image error'); // todo err message throw $e; } return $image; }
/** * @param FileUpload $fileUpload */ public function upload(FileUpload $fileUpload, $path) { if (!$fileUpload->isOk()) { throw new ImageUploadedException('Chyba při nahrávání obrázku'); } $fileUpload->move($path); }
/** * Process form file upload from FileUpload wrapper class. * * @param FileUpload $file * @return string */ public static function upload(FileUpload $file) { $filename = $file->getSanitizedName(); $folder = date('Y'); $file->move(self::getUploadDir() . $folder . '/' . $filename); return $folder . '/' . $filename; }
/** * @param FileUpload $file * @return array|void */ public function save(FileUpload $file) { if ($file->isImage()) { return $this->imageSaver->save($file); } else { return $this->fileSaver->save($file); } }
/** * @param FileUpload $file * @return string */ public function save(FileUpload $file) { do { $filename = Strings::random(5) . '-' . $file->getSanitizedName(); $targetFile = $this->getAbsolutePath() . '/' . $filename; } while (file_exists($targetFile)); $image = $file->toImage(); $image->save($targetFile); return $filename; }
/** * @param FileUpload $file * @return mixed|void * @throws NotAllowedFileException */ public function save(FileUpload $file) { $filename = $file->getSanitizedName(); $parts = explode('.', $filename); $last = end($parts); if (in_array($last, $this->notAllowed)) { throw new NotAllowedFileException("File with {$last} suffix is not allowed."); } $file->move($this->dir . '/' . $filename); }
protected function processImageUpload(Nette\Http\FileUpload $upload, $targetDir, $id) { $dir = 'upload' . DIRECTORY_SEPARATOR . $targetDir . DIRECTORY_SEPARATOR . $id; if (!file_exists($this->rootDir . DIRECTORY_SEPARATOR . $dir)) { Nette\Utils\FileSystem::createDir($this->rootDir . DIRECTORY_SEPARATOR . $dir); } $path = $dir . DIRECTORY_SEPARATOR . $upload->getSanitizedName(); $upload->move($this->rootDir . DIRECTORY_SEPARATOR . $path); return $path; }
/** * @param FileUpload $fileUpload * @return string */ public static function sanitizeFileName(FileUpload $fileUpload) { $filename = $fileUpload->getSanitizedName(); $filename = Strings::lower($filename); $fileInfo = new \SplFileInfo($filename); $suffix = $fileInfo->getExtension(); $basename = $fileInfo->getBasename(".{$suffix}"); $hash = md5($fileUpload->getContents()); $hash = Strings::substring($hash, 0, 9); return Strings::substring($basename, 0, 50) . "_{$hash}.{$suffix}"; }
protected function saveFile(FileUpload $upload) { if ($upload->ok) { $pathinfo = pathinfo($upload->name); $extension = in_array($pathinfo['extension'], $this->disableExtension) ? 'txt' : $pathinfo['extension']; $file = $this->path . '/' . md5(uniqid(rand(), true)) . '.' . $extension; $upload->move($this->wwwDir . '/' . $file); return ['name' => $upload->name, 'src' => $file]; } return NULL; }
$values->avatar = $this->_uploadTitleImage($values->avatar); if (is_file("www/" . $this->avatar_path . $values->old_avatar)) { unlink($this->www_dir . "/www/" . $this->avatar_path . $values->old_avatar); } $this->hlavne_menu->uloz(["avatar" => $values->avatar], $values->id); } else { throw new Database\DriverException('Pre titulný obrázok nebol použitý obrázok a tak nebol uložený!' . $e->getMessage()); } } else { throw new Database\DriverException('Pri pokuse o uloženie došlo k chybe! Pravdepodobná príčina je:' . $this->presenter->upload_error[$values->avatar->error] . $e->getMessage()); } } catch (Database\DriverException $e) {
/** * @param FileUpload $file * @return mixed|void */ public function save(FileUpload $file) { $filename = $file->getSanitizedName(); /** @var \Nette\Image */ $image = $file->toImage(); $image->save($this->dir . '/' . $filename); foreach ($this->dimensions as $prefix => $dimension) { $image->resize($dimension[0], $dimension[1], Image::SHRINK_ONLY); $image->save($this->dir . '/' . $prefix . '_' . $filename); } }
/** * @param FileUpload $file * @return Image * @throws \Nette\InvalidArgumentException */ public function upload(FileUpload $file) { if (!$file->isOk() || !$file->isImage()) { throw new Nette\InvalidArgumentException(); } do { $name = Random::generate() . '.' . $file->getSanitizedName(); } while (file_exists($path = $this->imagesDir . "/" . $this->namespace . $this->originalPrefix . "/" . $name)); $file->move($path); $this->onUploadImage($path, $this->namespace); $this->namespace = NULL; return new Image($path); }
/** * @param string $namespace * @param FileUpload $fileUpload * @return SplFileInfo * @throws UploadErrorException */ public function singleFileToDir($namespace, FileUpload $fileUpload) { if ($error = $fileUpload->getError()) { throw new UploadErrorException($error); } /** @var IManager $manager */ $manager = $this->managerProvider->get($fileUpload); $relativePath = Utils::normalizePath($manager->getStorage()->getRelativePath() . '/' . $namespace); $this->onFileBegin($fileUpload, $relativePath); $uploadedFile = $manager->upload($namespace, $fileUpload); $this->onFileComplete($uploadedFile, $fileUpload, $relativePath); return $uploadedFile; }
/** * Ověří mimetype předaného souboru. * @param \Nette\Http\FileUpload $file Nahraný soubor k ověření. * @return bool Má soubor správný mimetype? */ public function checkType(\Nette\Http\FileUpload $file) { if (\Nette\Utils\Arrays::searchKey($this->getMimeTypes(), $file->getContentType()) !== FALSE) { return TRUE; } else { // Pokud se nepodaří ověřit mimetype, ověříme alespoň koncovku. if (array_search($this->getExtension($file->getName()), array_unique($this->getMimeTypes())) !== FALSE) { return TRUE; } else { return FALSE; } } }
/** * @param FileUpload $fileUpload * @param string $namespace * @param callable $callback * @return string Absolute name */ public function saveUpload(FileUpload $fileUpload, $namespace = NULL, callable $callback = NULL) { if (!$fileUpload->isOk() || !$fileUpload->isImage()) { return NULL; } $image = $this->createImage(); $image->setNamespace($namespace); $image->setName($fileUpload->getSanitizedName()); if ($callback) { $callback($image); } $image->saveUpload($fileUpload); return (string) $image; }
/** * @param Nette\Http\FileUpload $file * @param $path */ public function upload(Nette\Http\FileUpload $file, $path) { try { $tempFile = $file->getTemporaryFile(); $uploadPath = $this->wwwDir . $path; $mainFile = $uploadPath . time() . '-' . $file->getName(); move_uploaded_file($tempFile, $mainFile); return $mainFile; } catch (\Exception $e) { header('HTTP/1.1 500 Internal Server Error'); header('Content-type: text/plain'); exit($e->getMessage()); } }
public function put(FileUpload $file) { if (!$file->ok) { $this->errors[] = "Při nahrávání obrázku " . $file->name . " nastala chyba " . $file->error; return false; } // Allow certain file formats $fileType = $this->verifyFileType(basename($file->name)); if (!$fileType) { $this->errors[] = "Nahraný soubor " . $file->name . " není jedním z povolených typů: " . implode(", ", self::allowedFileTypes()); return false; } // Check if image file is a actual image or fake image $dimensionErrors = self::checkImageDimensions($file->temporaryFile); if (!empty($dimensionErrors)) { $this->errors = $dimensionErrors; return false; } // Check file size if (($file_size = $file->size) > self::MAX_IMG_FILE_SIZE) { $errors[] = "Velikost souboru " . $file_size / 1024 . "kb přesáhla povolený limit " . self::MAX_IMG_FILE_SIZE / 1024 . "kb"; return false; } // if everything is ok, try to upload file $destFile = $this->uniqueFilename($file->name); $finalFileName = $this->imgFolder . $destFile; if (!$file->move($finalFileName)) { $errors[] = "Nahraný obrázek se nepodařilo uložit."; return false; } return $destFile; }
private function getInvalidMetadata(FileUpload $song) : array { $invalidMetadata = []; $songReader = new \SongReader($song->getTemporaryFile()); if (!$songReader->getDuration()) { $invalidMetadata[] = 'playtime_string'; } if (!$songReader->getAuthor()) { $invalidMetadata[] = 'artist'; } if (!$songReader->getTitle()) { $invalidMetadata[] = 'title'; } if (!$songReader->getAlbum()) { $invalidMetadata[] = 'album'; } return $invalidMetadata; }
public function thumbate(FileUpload $file, Thumb $thumb) { /** @var $image Image */ $image = $file->toImage(); $dimension = $thumb->getDimension(); // Resize to thumb dimension $image->resize($dimension->getWidth(), $dimension->getHeight(), $dimension->getFlag()); // Image name $imagename = $thumb->getImagename(); // File name $filename = $imagename . '.' . Utils::ext($file->name); // Gets properly directory $path = Utils::dirs($this->repository, $thumb->getPath(), $filename); // Store image data $this->images[] = ArrayHash::from(['path' => Utils::dirs($this->repository, $thumb->getPath()), 'fullpath' => $path, 'filename' => $filename, 'name' => $imagename, 'ext' => Utils::ext($file->name)]); // Save to file $image->save($path); }
public function __construct(FileUpload $file) { if (!$file->isImage()) { throw new NotImageUploadedException(); } $this->id = Uuid::uuid4(); $pathInfo = pathinfo($file->getSanitizedName()); if (!isset($pathInfo['extension'])) { throw new FileNameException('Filename must have extension'); } $this->extension = $pathInfo['extension']; $this->originalName = $pathInfo['filename']; $imgSize = $file->getImageSize(); $this->width = $imgSize[0]; $this->height = $imgSize[1]; $this->fileSize = $file->getSize(); $this->uploadedAt = new \DateTime('now'); }
/** * * @param \Nette\Http\FileUpload $file * @return string */ private function getImageBase64(\Nette\Http\FileUpload $file) { $type = $file->getContentType(); $img = Image::fromFile($file); $img->resize(100, 100, Image::EXACT); $img_string = ""; switch ($type) { case 'image/png': $img_string = $img->toString(Image::PNG); break; case 'image/jpeg': $img_string = $img->toString(Image::JPEG); break; case 'image/gif': $img_string = $img->toString(Image::GIF); break; } return 'data:' . $type . ';base64,' . base64_encode($img_string); }
/** * Prida soubor do db * @param \Nette\Http\FileUpload $file * @return type */ public function addFile($file, $userId = NULL) { if ($file instanceof \Nette\Http\FileUpload) { if (!$file->isOk()) { return false; } $folder = $this->getFolder('', FALSE); if (!$folder) { throw new VirtualDriveException('Current folder not found', 3011); } $name = $this->model->addFile($file, $folder['folder_id'], 0, $userId); /*if(!file_exists($this->getFullPath(TRUE).'/images')){ @mkdir($this->getFullPath(TRUE).'/images', 0777, TRUE); }*/ $filename = $this->uploadFile($file, $name); return $this->_getIdFromFileName($filename); } else { throw new VirtualDriveException('Wrong file type!', 3012); } }
/** * Return file upload error message. * @param FileUpload $file * @param UI\Presenter $presenter * @return bool */ public static function hasFileError(FileUpload $file, UI\Presenter &$presenter, $noFileError = TRUE) { switch ($file->getError()) { case UPLOAD_ERR_INI_SIZE: $presenter->flashMessage('The uploaded file exceeds the upload_max_filesize directive in php.ini.', 'error'); $return = FALSE; break; case UPLOAD_ERR_FORM_SIZE: $presenter->flashMessage('The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form.', 'error'); $return = FALSE; break; case UPLOAD_ERR_PARTIAL: $presenter->flashMessage('The uploaded file was only partially uploaded.', 'error'); $return = FALSE; break; case UPLOAD_ERR_NO_FILE: if ($noFileError === FALSE) { $presenter->flashMessage('No file was uploaded.', 'error'); } $return = $noFileError; break; case UPLOAD_ERR_NO_TMP_DIR: $presenter->flashMessage('Missing a temporary folder.', 'error'); $return = FALSE; break; case UPLOAD_ERR_CANT_WRITE: $this->flashMessage('Failed to write file to disk.', 'error'); $return = FALSE; break; case UPLOAD_ERR_EXTENSION: $presenter->flashMessage('File upload stopped by extension.', 'error'); $return = FALSE; break; default: $presenter->flashMessage('Chyba při zpracování souboru ' . $file->getName(), 'error'); $return = FALSE; break; } return $return; }
/** * Save file into filesystem and insert information into database. * Checks extension and gives file mime type. * @param FileUpload $file * @param int $goods_id * @param string $name * @param string $description * @return bool success */ public function insertPhoto($file, $goods_id, $name = '', $description = '') { $photo = new Photo($this->db); $filename = $file->getName(); $ext = self::getExtensionByName($filename); // povolene pripony $enabledExt = explode(' ', self::ENABLED_EXTENSION); if (!in_array($ext, $enabledExt)) { return false; } $lastPhoto_id = $photo->insert(array('name' => $name ? $name : $filename, 'goods_id' => $goods_id, 'description' => $description)); $photoFileName = $file->getTemporaryFile(); $photoFileNameBig = self::SAVE_DIR . $lastPhoto_id . '.big.jpg'; $photoFileNameSmall = self::SAVE_DIR . $lastPhoto_id . '.small.jpg'; try { $src = imagecreatefromjpeg($photoFileName); list($width, $height) = getimagesize($photoFileName); $aspectRatio = $width / $height; if ($aspectRatio > 1) { $targetWidth = 800; $targetHeight = round(800 / $aspectRatio); } else { $targetWidth = round(800 * $aspectRatio); $targetHeight = 800; } $bigThumbnail = imagecreatetruecolor($targetWidth, $targetHeight); imagecopyresampled($bigThumbnail, $src, 0, 0, 0, 0, $targetWidth, $targetHeight, $width, $height); imagejpeg($bigThumbnail, $photoFileNameBig, 75); $smallThumbnail = imagecreatetruecolor(round($targetWidth / 2.5), round($targetHeight / 2.5)); imagecopyresampled($smallThumbnail, $src, 0, 0, 0, 0, round($targetWidth / 2.5), round($targetHeight / 2.5), $width, $height); imagejpeg($smallThumbnail, $photoFileNameSmall, 50); } catch (\Exception $e) { $photo = new Photo($this->db); $photo->where('id', $lastPhoto_id)->delete(); return false; } return true; }
public function savaOriginImage($namespace, FileUpload $file) { if (!$file->isOk() || !$file->isImage()) { throw new ImageStorageException("invalid image"); } $i = 1; $name = $file->getSanitizedName(); $path = $this->getPath($namespace, $name); while (file_exists($path)) { $name = $i . '-' . $file->getSanitizedName(); $path = $this->getPath($namespace, $name); $i++; } $file->move($path); return $name; }
/** * @param FileUpload * @param string|NULL * @param array|string|NULL * @return string filepath (namespace/file.ext) * @throws ImageStorageException */ public function upload(FileUpload $image, $namespace = NULL, $mimeTypes = NULL) { if (!$image->isOk()) { throw new ImageStorageException('File is broken'); } if (!$image->isImage()) { $contentType = $image->getContentType(); $isValid = FALSE; if (isset($mimeTypes)) { $mimeTypes = is_array($mimeTypes) ? $mimeTypes : explode(',', $mimeTypes); $isValid = in_array($contentType, $mimeTypes, TRUE); } if (!$isValid) { throw new ImageStorageException('File must be image, ' . $contentType . ' given'); } } $sanitizedName = $image->getSanitizedName(); $ext = pathinfo($sanitizedName, PATHINFO_EXTENSION); $sanitizedName = pathinfo($sanitizedName, PATHINFO_FILENAME) . '.' . Strings::lower($ext); $file = $this->generateFilePath($sanitizedName, $namespace); $path = $this->getPath($file); $image->move($path); return $file; }