/**
* Handles an uploaded file by putting it in the $targetDir.
*
* @param UploadedFile $uploadedFile File object that has been uploaded - usually taken from Request object.
* @param string $targetDir [optional] Where to (relatively to the storage root dir) put the file?
* @param array $allowed [optional] What files are allowed? If not matching then will throw exception.
* @param int $maxFileSize [optional] What is the maximum allowed file size for this file?
* @return File
*/
public function handleUploadedFile(UploadedFile $uploadedFile, $targetDir = '/', array $allowed = array(), $maxFileSize = 0)
{
array_walk($allowed, function ($ext) {
return strtolower($ext);
});
$targetDir = trim($targetDir, '/');
$targetDir = $this->path . $targetDir . (empty($targetDir) ? '' : '/');
$filenameElements = explode('.', $uploadedFile->getClientOriginalName());
$extension = array_pop($filenameElements);
$extension = strtolower($extension);
$filename = implode('.', $filenameElements);
$targetName = StringUtils::fileNameFriendly($filename . '-' . StringUtils::random() . '.' . $extension);
$targetPath = $targetDir . $targetName;
// create unique file name
while (file_exists($targetPath)) {
$targetName = StringUtils::fileNameFriendly($filename . '-' . StringUtils::random() . '.' . $extension);
$targetPath = $targetDir . $targetName;
}
// basic check for allowed type
if (!empty($allowed) && !in_array($extension, $allowed)) {
throw new FileException('The uploaded file is not of a valid type (allowed: ' . implode(', ', $allowed) . ').');
}
// basic check for max allowed size
if ($maxFileSize && $uploadedFile->getSize() > $maxFileSize) {
throw new FileException('The uploaded file is too big (max allowed size is ' . StringUtils::bytesToString($maxFileSize) . ').');
}
try {
$movedFile = $uploadedFile->move(rtrim($targetDir, '/'), $targetName);
} catch (SfFileException $e) {
// if exception thrown then convert it to our exception
throw new FileException($e->getMessage(), $e->getCode());
}
$file = $this->convertSfFileToStorageFile($movedFile);
return $file;
}
/**
* Orientate the image.
*
* @param UploadedFile $file
* @param $orientation
* @return UploadedFile
*/
protected function orientate(UploadedFile $file, $orientation)
{
$image = imagecreatefromjpeg($file->getRealPath());
switch ($orientation) {
case 2:
imageflip($image, IMG_FLIP_HORIZONTAL);
break;
case 3:
$image = imagerotate($image, 180, 0);
break;
case 4:
$image = imagerotate($image, 180, 0);
imageflip($image, IMG_FLIP_HORIZONTAL);
break;
case 5:
$image = imagerotate($image, -90, 0);
imageflip($image, IMG_FLIP_HORIZONTAL);
break;
case 6:
$image = imagerotate($image, -90, 0);
break;
case 7:
$image = imagerotate($image, 90, 0);
imageflip($image, IMG_FLIP_HORIZONTAL);
break;
case 8:
$image = imagerotate($image, 90, 0);
break;
}
imagejpeg($image, $file->getRealPath(), 90);
return new UploadedFile($file->getRealPath(), $file->getClientOriginalName(), $file->getMimeType(), $file->getSize());
}
/**
* {@inheritdoc}
*
* @param null|\Symfony\Component\HttpFoundation\File\UploadedFile $data
*/
public function convertFieldValueFromForm($data)
{
if ($data === null) {
return null;
}
return array("inputUri" => $data->getRealPath(), "fileName" => $data->getClientOriginalName(), "fileSize" => $data->getSize());
}
public function process(UploadedFile $file)
{
// File extension
$this->extension = $file->getClientOriginalExtension();
// Mimetype for the file
$this->mimetype = $file->getMimeType();
// Current user or 0
$this->user_id = Auth::user() ? Auth::user()->id : 0;
$this->size = $file->getSize();
list($this->path, $this->filename) = $this->upload($file);
$this->save();
// Check to see if image thumbnail generation is enabled
if (static::$app['config']->get('cabinet::image_manipulation')) {
$thumbnails = $this->generateThumbnails($this->path, $this->filename);
$uploads = array();
foreach ($thumbnails as $thumbnail) {
$upload = new $this();
$upload->filename = $thumbnail->fileSystemName;
$upload->path = static::$app['config']->get('cabinet::upload_folder_public_path') . $this->dateFolderPath . $thumbnail->fileSystemName;
// File extension
$upload->extension = $thumbnail->getClientOriginalExtension();
// Mimetype for the file
$upload->mimetype = $thumbnail->getMimeType();
// Current user or 0
$upload->user_id = $this->user_id;
$upload->size = $thumbnail->getSize();
$upload->parent_id = $this->id;
$upload->save();
$uploads[] = $upload;
}
$this->children = $uploads;
}
}
public function testGetSize()
{
$file = new UploadedFile(__DIR__ . '/Fixtures/test.gif', 'original.gif', 'image/gif', filesize(__DIR__ . '/Fixtures/test.gif'), null);
$this->assertEquals(filesize(__DIR__ . '/Fixtures/test.gif'), $file->getSize());
$file = new UploadedFile(__DIR__ . '/Fixtures/test', 'original.gif', 'image/gif');
$this->assertEquals(filesize(__DIR__ . '/Fixtures/test'), $file->getSize());
}
public function validateMaxSize($attribute, UploadedFile $value, $parameters)
{
$mediaPath = public_path(config('asgard.media.config.files-path'));
$folderSize = $this->getDirSize($mediaPath);
preg_match('/([0-9]+)/', $folderSize, $match);
return $match[0] + $value->getSize() < config('asgard.media.config.max-total-size');
}
/**
* converts UploadedFile to $_FILES array
*
* @return array
*/
public function getFileArray()
{
$array = array('name' => $this->uploaded_file->getClientOriginalName(), 'type' => $this->uploaded_file->getClientMimeType(), 'tmp_name' => $this->uploaded_file->getPath() . $this->getOSDirectorySeparator() . $this->uploaded_file->getFilename(), 'error' => $this->uploaded_file->getError(), 'size' => $this->uploaded_file->getSize(), 'dimension' => array('width' => 0, 'height' => 0));
if (preg_match('/^image/', $array['type'])) {
list($array['dimension']['width'], $array['dimension']['height']) = getimagesize($this->uploaded_file);
}
return $array;
}
/**
* Checks if the passed value is valid.
*
* @param UploadedFile $file The value that should be validated
* @param Constraint $constraint The constraint for the validation
*/
public function validate($file, Constraint $constraint)
{
if (!in_array($file->getMimeType(), $this->mimeTypes)) {
$this->context->buildViolation($constraint->messageMimeTypes)->atPath('file')->addViolation();
}
if ($file->getSize() > $file->getMaxFilesize()) {
$this->context->buildViolation($constraint->messageMaxSize, array('%max_size%' => $file->getMaxFilesize()))->atPath('file')->addViolation();
}
}
/**
* Determines if the file is too large
*
* @throws Exception
*/
private function determineFilesizeLimit()
{
$php_ini = ini_get('upload_max_filesize');
$mb = str_replace('M', '', $php_ini);
$bytes = $mb * 1048576;
if ($this->file->getSize() > $bytes) {
throw new \Exception('File too large');
}
}
/**
* Setup image file
*
* @param UploadedFile $file
* @param string $style_guide
*/
public function setupFile(UploadedFile $file, $style_guide = null)
{
$this->_source = $file;
$this->setFileExtension($file->getClientOriginalExtension());
$this->setFileNameAttribute($file->getClientOriginalName());
$this->setMimeTypeAttribute($file->getClientMimeType());
$this->setFileSizeAttribute($file->getSize());
if (!empty($style_guide)) {
$this->setStyleGuideName($style_guide);
}
}
/**
* @param UploadedFile $uploadedFile
* @param FileEntity $fileEntity
* @return bool
*/
public function putUploadedFile(UploadedFile $uploadedFile, FileEntity $fileEntity)
{
list($path, $filesystem, $settings) = $this->getConfigValuesForRecordType($fileEntity->getRecordType());
$fullPath = $path . DIRECTORY_SEPARATOR . $fileEntity->getFileName();
$this->getFilesystem($filesystem)->putStream($fullPath, fopen($uploadedFile->getPathname(), 'r'), $settings);
$fileEntity->setContentType($uploadedFile->getMimeType())->setSize($uploadedFile->getSize());
/** @var EntityManager $em */
$em = $this->container['orm.em'];
$em->flush();
return $fileEntity;
}
/**
* @param UploadedFile $file
* @return Document
*/
public function add(UploadedFile $file)
{
$document = new Document();
$document->setExtension($file->guessExtension())->setMime($file->getMimeType())->setName($file->getClientOriginalName())->setSize($file->getSize());
if (is_null($document->getExtension())) {
$document->setExtension($file->getClientOriginalExtension());
}
$this->em->persist($document);
$this->em->flush();
$file->move($this->directory . '/' . substr($document->getId(), 0, 1), $document->getId() . '.' . $document->getExtension());
return $document;
}
/**
* @param string $email
* @return UploadedFile
* @throws InvalidArgumentException
*/
public function getFile($email)
{
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException();
}
$hash = md5(strtolower(trim($email)));
$guzzle = new Client();
$tempDirectory = sys_get_temp_dir();
$guzzle->request("GET", "http://gravatar.com/avatar/" . $hash . "?d=404", [RequestOptions::SINK => $tempDirectory . '/' . $hash]);
$file = new File($tempDirectory . '/' . $hash);
$fileOriginalName = $hash . '.' . $file->guessExtension();
$file = new UploadedFile($tempDirectory . '/' . $hash, $fileOriginalName, $file->getMimeType(), $file->getSize(), null, true);
return $file;
}
/**
* @param UploadedFile $file
* @param array $methods
*
* @return mixed|void
*
* @throws InvalidFileTypeException
* @throws InvalidFileException
* @throws UploadFileNotSetException
* @throws MaxFileSizeExceededException
*/
public function validate(UploadedFile $file, $methods = [self::VALIDATOR_FILE_SET, self::VALIDATOR_FILE_ERRORS, self::VALIDATOR_BLOCK_FILE_TYPES, self::VALIDATOR_MAX_FILE_SIZE])
{
if (in_array(self::VALIDATOR_FILE_ERRORS, $methods) && $file->getError() > 0) {
throw new InvalidFileException(sprintf('The file upload had an error("%s: %s")', $file->getError(), $file->getErrorMessage()));
}
if (in_array(self::VALIDATOR_FILE_SET, $methods) && $file->getFilename() == '') {
throw new UploadFileNotSetException(sprintf('No file "%s" was set', $file->getFilename()));
}
if (in_array(self::VALIDATOR_BLOCK_FILE_TYPES, $methods) && in_array($file->getMimeType(), $this->blockedMimeTypes)) {
throw new InvalidFileTypeException(sprintf('The file type "%s" was blocked', $file->getMimeType()));
}
if (in_array(self::VALIDATOR_MAX_FILE_SIZE, $methods) && $this->maxFileSize !== null && $file->getSize() >= $this->maxFileSize) {
throw new MaxFileSizeExceededException(sprintf('File "%s" exceeds the configured maximum filesize of "%s"', $file->getFilename(), $this->maxFilesize));
}
}
/**
* @param FileInterface $storageFile
* @param UploadedFile $uploadData
*/
public function createFromUploadedFile(FileInterface $storageFile, UploadedFile $uploadData)
{
$fileSystem = new Filesystem();
$storageFile->setFileName($uploadData->getClientOriginalName());
$storageFile->setMimeType($uploadData->getMimeType());
$storageFile->setSize($uploadData->getSize());
if (!$storageFile->getId()) {
$this->save($storageFile);
} else {
$fileSystem->remove($this->getFilePath($storageFile));
}
$storageFile->setStorageId(uniqid($storageFile->getId() . '_', false));
$uploadData->move($this->getStorageDirectory($storageFile), $storageFile->getStorageId());
$this->save($storageFile);
}
public static function upload(UploadedFile $file, $user)
{
$userId = $user;
if ($user instanceof User) {
$userId = $user->id;
}
$hash = md5_file($file->getPathname());
$image = Image::whereHash($hash)->whereUploadedBy($userId)->first();
if ($image) {
return $image;
}
$image = new Image();
try {
$image->uploaded_by = $userId;
$image->size = $file->getSize();
$image->filename = $file->getClientOriginalName();
$image->extension = $file->getClientOriginalExtension();
$image->mime = $file->getMimeType();
$image->hash = $hash;
$image->save();
$image->ensureDirectoryExists();
foreach (self::$ImageTypes as $coverType) {
if ($coverType['id'] === self::ORIGINAL && $image->mime === 'image/jpeg') {
$command = 'cp ' . $file->getPathname() . ' ' . $image->getFile($coverType['id']);
} else {
// ImageMagick options reference: http://www.imagemagick.org/script/command-line-options.php
$command = 'convert 2>&1 "' . $file->getPathname() . '" -background white -alpha remove -alpha off -strip';
if ($image->mime === 'image/jpeg') {
$command .= ' -quality 100 -format jpeg';
} else {
$command .= ' -quality 95 -format png';
}
if (isset($coverType['width']) && isset($coverType['height'])) {
$command .= " -thumbnail {$coverType['width']}x{$coverType['height']}^ -gravity center -extent {$coverType['width']}x{$coverType['height']}";
}
$command .= ' "' . $image->getFile($coverType['id']) . '"';
}
External::execute($command);
chmod($image->getFile($coverType['id']), 0644);
}
return $image;
} catch (\Exception $e) {
$image->delete();
throw $e;
}
}
public function store(UploadedFile $file)
{
$file->getClientOriginalName();
$fileResult = \DB::table('file')->where('name', $file->getClientOriginalName())->where('checksum', md5_file($file->getRealPath()))->first();
if (isset($fileResult->id)) {
return $fileResult;
}
$fileResult = new Models\file();
$fileResult->name = $file->getClientOriginalName();
$fileResult->size = $file->getSize();
$fileResult->mime_type = $file->getMimeType();
$fileResult->checksum = md5_file($file->getRealPath());
$fileResult->save();
$fileResult->path = $this->moveFile($file, $fileResult->id);
$fileResult->save();
return $fileResult;
}
public function createFromFile(UploadedFile $newMedia, SiteModel $site, UserAccountModel $user, $title = null, $sourceText = null, $sourceURL = null)
{
global $CONFIG;
if ($newMedia && in_array(strtolower($newMedia->guessExtension()), MediaModel::getAllowedImageExtensions())) {
$media = new MediaModel();
$media->setSiteId($site->getId());
$media->setStorageSize($newMedia->getSize());
$media->setTitle($title);
$media->setSourceText($sourceText);
$media->setSourceUrl($sourceURL);
$media->setMd5(md5_file($newMedia->getRealPath()));
$this->create($media, $user);
$storeDirectory = $CONFIG->fileStoreLocation . DIRECTORY_SEPARATOR . "media";
$extension = strtolower($newMedia->guessExtension());
$newMedia->move($storeDirectory, $media->getId() . "." . $extension);
return $media;
}
}
public static function updateIcon(Application $app, $databox_id, $bit, $switch, UploadedFile $file)
{
$databox = $app->findDataboxById($databox_id);
$statusStructure = $app['factory.status-structure']->getStructure($databox);
if (!$statusStructure->hasStatus($bit)) {
throw new InvalidArgumentException(sprintf('bit %s does not exists', $bit));
}
$status = $statusStructure->getStatus($bit);
$switch = in_array($switch, ['on', 'off']) ? $switch : false;
if (!$switch) {
throw new Exception_InvalidArgument();
}
$url = $statusStructure->getUrl();
$path = $statusStructure->getPath();
if ($file->getSize() >= 65535) {
throw new Exception_Upload_FileTooBig();
}
if (!$file->isValid()) {
throw new Exception_Upload_Error();
}
self::deleteIcon($app, $databox_id, $bit, $switch);
$name = "-stat_" . $bit . "_" . ($switch == 'on' ? '1' : '0') . ".gif";
try {
$file = $file->move($app['root.path'] . "/config/status/", $path . $name);
} catch (FileException $e) {
throw new Exception_Upload_CannotWriteFile();
}
$custom_path = $app['root.path'] . '/www/custom/status/';
$app['filesystem']->mkdir($custom_path, 0750);
//resize status icon 16x16px
$imageSpec = new ImageSpecification();
$imageSpec->setResizeMode(ImageSpecification::RESIZE_MODE_OUTBOUND);
$imageSpec->setDimensions(16, 16);
$filePath = sprintf("%s%s", $path, $name);
$destPath = sprintf("%s%s", $custom_path, basename($path . $name));
try {
$app['media-alchemyst']->turninto($filePath, $destPath, $imageSpec);
} catch (\MediaAlchemyst\Exception $e) {
}
$status['img_' . $switch] = $url . $name;
$status['path_' . $switch] = $filePath;
return true;
}
/**
* @param UploadedFile $uploadedFile
* @return null|string
*/
protected function handleFileUpload($uploadedFile, $delimiter = ',', $enclosure = '"')
{
$errMsg = '';
if (!$uploadedFile instanceof UploadedFile) {
$errMsg = _("No file selected");
} elseif ($uploadedFile->getSize() == 0 && $uploadedFile->getError() == 0) {
$errMsg = _("Larger than upload_max_filesize ") . ini_get(self::KEY_UPLOAD_MAX_FILESIZE);
} elseif ($uploadedFile->getClientOriginalExtension() != 'csv') {
$errMsg = _('Invalid extension ') . $uploadedFile->getClientOriginalExtension() . ' of file ' . $uploadedFile->getClientOriginalName();
}
if (!empty($errMsg)) {
return $errMsg;
}
/** @var LicenseCsvImport */
$licenseCsvImport = $this->getObject('app.license_csv_import');
$licenseCsvImport->setDelimiter($delimiter);
$licenseCsvImport->setEnclosure($enclosure);
return $licenseCsvImport->handleFile($uploadedFile->getRealPath());
}
/**
* Save input data to database
*/
public function make()
{
// save data to db
$this->_record->title = $this->title;
$this->_record->text = $this->text;
$this->_record->path = $this->path;
$this->_record->category_id = (int) $this->categoryId;
$this->_record->display = 0;
// set to premoderation
$this->_record->author_id = (int) $this->authorId;
if ($this->_new === true) {
$this->_record->comment_hash = $this->generateCommentHash();
}
$this->_record->save();
// work with poster data
if ($this->poster !== null) {
// lets move poster from tmp to gallery
$originDir = '/upload/gallery/' . $this->_record->id . '/orig/';
$thumbDir = '/upload/gallery/' . $this->_record->id . '/thumb/';
if (!Directory::exist($originDir)) {
Directory::create($originDir);
}
if (!Directory::exist($thumbDir)) {
Directory::create($thumbDir);
}
$fileName = App::$Security->simpleHash($this->poster->getClientOriginalName() . $this->poster->getSize());
$newFullName = $fileName . '.' . $this->poster->guessExtension();
// move poster to upload gallery directory
$this->poster->move(Normalize::diskFullPath($originDir), $newFullName);
// initialize image resizer
$thumb = new Image();
$thumb->setCacheDir(root . '/Private/Cache/images');
// open original file, resize it and save
$thumbSaveName = Normalize::diskFullPath($thumbDir) . '/' . $fileName . '.jpg';
$thumb->open(Normalize::diskFullPath($originDir) . DIRECTORY_SEPARATOR . $newFullName)->cropResize($this->_configs['galleryResize'])->save($thumbSaveName, 'jpg', 90);
$thumb = null;
// update poster in database
$this->_record->poster = $newFullName;
$this->_record->save();
}
}
public function upload(UploadedFile $uploadedFile)
{
$this->completeFile = null;
// pega o range-content (Content-Range: bytes 0-123/400)
$range = $this->getContentRange();
$rangeTotal = $range['total'];
// pega o nome do arquivo (pode estar no Content-Disposition: attachment; filename="x")
$originalName = $this->getContentDispositionFilename($uploadedFile->getClientOriginalName());
if ($uploadedFile->getSize() < (int) $rangeTotal) {
// chunk
file_put_contents($this->path . $originalName, fopen($uploadedFile->getPathname(), 'r'), FILE_APPEND);
$parcialFile = new File($this->path . $originalName);
$this->completeFile = $parcialFile->getSize() < (int) $rangeTotal ? null : $parcialFile;
return null !== $this->completeFile ? self::COMPLETE : self::PARTIAL;
} else {
if (is_file($this->path . $originalName)) {
$this->completeFile = new File($this->path . $originalName);
} else {
$this->completeFile = $uploadedFile->move($this->path, $originalName);
}
return self::COMPLETE;
}
}
/**
* @param UploadedFile $file
*
* @return bool
*/
protected function validSize(UploadedFile $file) : bool
{
$size = $file->getSize();
$name = e($file->getClientOriginalName());
if ($size > $this->maxUploadSize) {
$msg = (string) trans('validation.file_too_large', ['name' => $name]);
$this->errors->add('attachments', $msg);
return false;
}
return true;
}
/**
* Creates a PSR-7 UploadedFile instance from a Symfony one.
*
* @param UploadedFile $symfonyUploadedFile
*
* @return UploadedFileInterface
*/
private function createUploadedFile(UploadedFile $symfonyUploadedFile)
{
return new DiactorosUploadedFile($symfonyUploadedFile->getRealPath(), $symfonyUploadedFile->getSize(), $symfonyUploadedFile->getError(), $symfonyUploadedFile->getClientOriginalName(), $symfonyUploadedFile->getClientMimeType());
}
/**
* upload file
*
* @param \Symfony\Component\HttpFoundation\File\UploadedFile $file
* @param string $path
* @param string $name
* @param string $type
* @return array
* @throws \browner12\uploader\UploaderException
*/
protected function upload(UploadedFile $file, $path, $name = null, $type)
{
//check file size
$this->checkSize($file->getSize());
//check extension
$this->checkExtension($file->getClientOriginalExtension(), $type);
//check mime type
$this->checkMimeType($file->getMimeType(), $type);
//if a name is not passed, we will use the original file name
$name = $name ?: $this->sanitizeFileName($file);
//determine filename
$newFilename = $name . '.' . strtolower($file->getClientOriginalExtension());
//successful upload
if ($file->move($path, $newFilename)) {
//return
return ['id' => $name, 'name' => $newFilename, 'size' => $file->getClientSize(), 'mime_type' => $file->getClientMimeType(), 'extension' => $file->getClientOriginalExtension(), 'original_name' => $file->getClientOriginalName(), 'url' => $path . $newFilename];
}
//failed upload
throw new UploaderException('Could not upload ' . $type . $file->getClientOriginalName() . '.');
}
/**
* Check if the given file is valid.
*
* @param \Symfony\Component\HttpFoundation\File\UploadedFile $file
* @return bool
* @throws \Cartalyst\Filesystem\Exceptions\MaxFileSizeExceededException
* @throws \Cartalyst\Filesystem\Exceptions\InvalidMimeTypeException
*/
public function validateFile(UploadedFile $file)
{
// Get the filesystem manager
$manager = $this->getManager();
// Get all the allowed mime types
$allowedMimes = $manager->getAllowedMimes();
// Validate the file size
if ($file->getSize() > $manager->getMaxFileSize()) {
throw new MaxFileSizeExceededException();
}
// Validate the file mime type
if (!empty($allowedMimes) && !in_array($file->getClientMimeType(), $allowedMimes)) {
throw new InvalidMimeTypeException();
}
return true;
}
/**
* Extract the file information from the uploaded file, into the internal properties
*/
private function setFileInfo()
{
if ($this->file === null) {
return;
}
if ($this->file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
//load file information
$fileInfo = pathinfo($this->file->getClientOriginalName());
$extension = $fileInfo['extension'];
$name = $fileInfo['filename'];
} else {
$extension = $this->file->guessExtension();
$name = $this->file->getBasename();
}
//set the file type using the type mapping
if (array_key_exists(strtolower($extension), $this->typeMapping)) {
$this->type = $this->typeMapping[strtolower($extension)];
} else {
$this->type = self::TYPE_UNKNOWN;
}
// The filesize in bytes.
$this->fileSize = $this->file->getSize();
$this->name = $this->removeSpecialCharacters($name);
$this->extension = $extension;
$this->path = str_replace(Shopware()->OldPath(), '', $this->getUploadDir() . $this->getFileName());
if (DIRECTORY_SEPARATOR !== '/') {
$this->path = str_replace(DIRECTORY_SEPARATOR, '/', $this->path);
}
}
/**
* Set file info from uploading file
*
* @param UploadedFile $file
* @return $this
*/
public function uploading(UploadedFile $file)
{
$this->setMime($file->getMimeType());
$this->file->extension = $file->getClientOriginalExtension();
$this->setName(pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME));
$this->file->bytes = $file->getSize();
$this->file->updated_at = date('Y-m-d H:i:s');
$this->setFileThumb(true);
return $this;
}
/**
* Returns an array of data for upload model
*
* @param UploadedFile $uploadedFile
* @return array
*/
protected function prepareUploadData(UploadedFile $uploadedFile)
{
return ['extension' => $uploadedFile->getExtension(), 'mimetype' => $uploadedFile->getMimeType(), 'size' => $uploadedFile->getSize(), 'name' => $uploadedFile->getBasename('.' . $uploadedFile->getExtension())];
}
/**
* Upload provided file and create matching FileRecord object
*
* @param UploadedFile $file
* @param $clientIp
* @return FileRecord
*/
public function uploadFile(UploadedFile $file, $clientIp)
{
$extension = Str::lower($file->getClientOriginalExtension());
$generatedName = $this->generateName($extension);
// Create SHA-256 hash of file
$fileHash = hash_file('sha256', $file->getPathname());
// Check if file already exists
$existingFile = FileRecord::where('hash', '=', $fileHash)->first();
if ($existingFile) {
return $existingFile;
}
// Query previous scans in VirusTotal for this file
if (config('virustotal.enabled') === true) {
$this->checkVirusTotalForHash($fileHash);
}
// Get filesize
$filesize = $file->getSize();
// Check max upload size
$maxUploadSize = config('upload.max_size');
if ($filesize > $maxUploadSize) {
throw new MaxUploadSizeException();
}
// Move the file
$uploadDirectory = config('upload.directory');
$file->move($uploadDirectory, $generatedName);
// Create the record
/** @var FileRecord $record */
$record = FileRecord::create(['client_name' => $file->getClientOriginalName(), 'generated_name' => $generatedName, 'filesize' => $filesize, 'hash' => $fileHash, 'uploaded_by_ip' => $clientIp]);
return $record;
}
