getSanitizedName() public method

Returns the sanitized file name.
public getSanitizedName ( ) : string
return string
Example #1
1
 /**
  * @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());
         }
     }
 }
Example #2
0
 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;
 }
Example #3
0
 /**
  * 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;
 }
Example #4
0
 /**
  * @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;
 }
Example #5
0
 /**
  * @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);
 }
Example #6
0
 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;
 }
Example #7
0
 /**
  * @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);
     }
 }
Example #8
0
 /**
  * @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}";
 }
             $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) {
Example #10
0
 /**
  * @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);
 }
Example #11
0
 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  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;
 }
Example #13
0
 /**
  * @param \Nette\Http\FileUpload $fileUpload
  * @return string
  */
 protected function upload(FileUpload $fileUpload)
 {
     $fileName = $fileUpload->getSanitizedName();
     while (file_exists($this->uploadPath . '/' . $fileName)) {
         $fileName = Random::generate() . $fileUpload->getSanitizedName();
     }
     $uploadPath = $this->uploadPath . '/' . $fileName;
     $fileUpload->move($uploadPath);
     return $uploadPath;
 }
 /**
  * save file and return path
  *
  * @param Nette\Http\FileUpload $image
  * @return string
  * @throws \Nette\Utils\UnknownImageFileException
  */
 public function saveImage(Nette\Http\FileUpload $image)
 {
     $filename = $image->getSanitizedName();
     $path = $this->dir;
     $filename = $this->getFileName($path, $filename);
     $image->move("{$path}/{$filename}");
     $filePath = "{$this->uri}/{$filename}";
     $image = Image::fromFile("{$path}/{$filename}");
     $image->resize(150, 150, Image::EXACT);
     $image->save("{$path}/{$filename}");
     return $filePath;
 }
Example #15
0
 /**
  * @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;
 }
 /**
  * Uložení nahraného souboru.
  * @param \Nette\Http\FileUpload $file
  * @return mixed Vlastní navrátová hodnota.
  */
 public function save(\Nette\Http\FileUpload $file)
 {
     return $file->getSanitizedName();
 }
Example #17
0
 /**
  * @param FileUpload $file
  *
  * @return ArrayHash
  */
 private function getFileData(FileUpload $file)
 {
     $name = $file->getSanitizedName();
     $extension = '';
     if (Strings::contains($name, '.')) {
         $fragments = explode('.', $name);
         array_shift($fragments);
         $extension = implode('.', $fragments);
     }
     $pairs = $this->storageDao->findPairs([], 'name', [], 'id');
     $data = new ArrayHash();
     while (true) {
         $name = Random::generate(10, '0-9A-Za-z');
         if (!in_array($name, $pairs)) {
             $data->name = $name;
             $data->extension = $extension;
             break;
         }
     }
     return $data;
 }
Example #18
0
 /**
  * Save uploaded file
  *
  * @param FileUpload $file
  * @param string $path
  * @return string
  */
 public static function save(FileUpload $file, $path)
 {
     if (!$file->isOk()) {
         return FALSE;
     }
     $pathName = self::prepareToSaveFile($file->getSanitizedName(), $path);
     $file->move($pathName);
     return basename($pathName);
 }
Example #19
0
File: File.php Project: venne/files
 /**
  * @internal
  *
  * @ORM\PreFlush()
  */
 public function preFlush()
 {
     if ($this->removed) {
         return;
     }
     if ($this->file) {
         if ($this->file instanceof FileUpload) {
             $basename = $this->file->getSanitizedName();
             $basename = $this->suggestName($basename);
             $this->setName($basename);
         } else {
             $basename = trim(Strings::webalize($this->file->getBasename(), '.', false), '.-');
             $basename = $this->suggestName($basename);
             $this->setName($basename);
         }
         if ($this->oldPath && $this->oldPath !== $this->path) {
             $filePath = $this->getFilePathBy($this->oldProtected, $this->oldPath);
             if (!is_file($filePath)) {
                 throw new RemoveFileException(sprintf('File \'%s\' does not exist.', $filePath));
             }
             unlink($filePath);
             if (is_file($filePath)) {
                 throw new RemoveFileException(sprintf('File \'%s\' cannot be removed. Check access rights.', $filePath));
             }
         }
         if ($this->file instanceof FileUpload) {
             try {
                 $filePath = $this->getFilePath();
                 $this->file->move($filePath);
             } catch (\Nette\InvalidStateException $e) {
                 throw new UploadFileException();
             }
             if (!is_file($filePath)) {
                 throw new RemoveFileException(sprintf('File \'%s\' does not exist.', $filePath));
             }
         } else {
             $oldFilePath = $this->file->getPathname();
             $filePath = $this->getFilePath();
             if (!is_file($oldFilePath)) {
                 throw new RenameFileException(sprintf('File \'%s\' does not exist.', $oldFilePath));
             }
             if (is_file($filePath)) {
                 throw new RenameFileException(sprintf('File \'%s\' already exists.', $filePath));
             }
             copy($oldFilePath, $filePath);
             if (!is_file($filePath)) {
                 throw new RenameFileException(sprintf('File \'%s\' does not exist.', $filePath));
             }
         }
         $this->size = filesize($this->getFilePath());
         $this->mimeType = finfo_file(finfo_open(FILEINFO_MIME_TYPE), $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 !== null ? $this->oldPath : $this->path);
         $filePath = $this->getFilePath();
         if (!is_file($oldFilePath)) {
             throw new RenameFileException(sprintf('File \'%s\' does not exist.', $oldFilePath));
         }
         if (is_file($filePath)) {
             throw new RenameFileException(sprintf('File \'%s\' already exists.', $filePath));
         }
         rename($oldFilePath, $filePath);
         if (is_file($oldFilePath)) {
             throw new RenameFileException(sprintf('File \'%s\' already exists.', $oldFilePath));
         }
         if (!is_file($filePath)) {
             throw new RenameFileException(sprintf('File \'%s\' does not exist.', $filePath));
         }
     }
 }
Example #20
0
 /**
  * @param \Nette\Http\FileUpload $file
  * @param string $filename
  * @throws IOException
  * @return string
  */
 public function writeUploaded(Nette\Http\FileUpload $file, $filename = NULL)
 {
     if (!$file->isOk()) {
         throw new IOException("Cannot save corrupted file.");
     }
     do {
         $name = Nette\Utils\Strings::random(10) . '.' . ($filename ?: $file->getSanitizedName());
     } while (file_exists($path = $this->dir . DIRECTORY_SEPARATOR . $name));
     $file->move($path);
     return basename($path);
 }