/**
* Create track from local hard drive with job service
*
* @param MultimediaObject $multimediaObject
* @param UploadedFile $file
* @param string $profile
* @param int $priority
* @param string $language
* @param array $description
* @return MultimediaObject
*/
public function createTrackFromLocalHardDrive(MultimediaObject $multimediaObject, UploadedFile $trackFile, $profile, $priority, $language, $description)
{
if (null === $this->profileService->getProfile($profile)) {
throw new \Exception("Can't find given profile with name " . $profile);
}
if (UPLOAD_ERR_OK != $trackFile->getError()) {
throw new \Exception($trackFile->getErrorMessage());
}
if (!is_file($trackFile->getPathname())) {
throw new FileNotFoundException($trackFile->getPathname());
}
$pathFile = $trackFile->move($this->tmpPath . "/" . $multimediaObject->getId(), $trackFile->getClientOriginalName());
$this->jobService->addJob($pathFile, $profile, $priority, $multimediaObject, $language, $description);
return $multimediaObject;
}
public function upload(UploadedFile $file, $filename, $headers = array())
{
$adapter = $this->filesystem->getAdapter();
$adapter->setMetadata($filename, $headers);
$adapter->write($filename, file_get_contents($file->getPathname()));
@unlink($file->getPathname());
return $filename;
}
/**
* Save file to folder.
*
* @author Casper Rasmussen <*****@*****.**>
*
* @param \Symfony\Component\HttpFoundation\File\UploadedFile $uploadedFile
* @param \Nodes\Assets\Upload\Settings $settings
*
* @return string
* @throws \Nodes\Assets\Upload\Exceptions\AssetsUploadFailedException
*/
protected function store(UploadedFile $uploadedFile, Settings $settings)
{
// Fallback folder is none is set
if (!$settings->hasFolder()) {
$settings->setFolder('default');
}
try {
// Retrieve folder path
$path = public_path(config('nodes.assets.providers.publicFolder.subFolder')) . DIRECTORY_SEPARATOR . $settings->getFolder();
// If folder doesn't exists,
// we'll create it with global permissions
if (!file_exists($path)) {
mkdir($path, 0777, true);
}
// Stream uploaded file
$content = file_get_contents($uploadedFile->getPathname());
// Save uploaded file to folder
$result = file_put_contents($path . DIRECTORY_SEPARATOR . $settings->getFileName() . '.' . $settings->getFileExtension(), $content);
if (!$result) {
throw new NodesException('Failed to save', 500);
}
} catch (Exception $e) {
throw new AssetsUploadFailedException('Could not save the file to public folder. Reason: ' . $e->getMessage());
}
return $settings->getFilePath();
}
/**
* Set a pic from an url into the event
*/
public function addPicFile(Event $event, UploadedFile $picFile)
{
if (UPLOAD_ERR_OK != $picFile->getError()) {
throw new \Exception($picFile->getErrorMessage());
}
if (!is_file($picFile->getPathname())) {
throw new FileNotFoundException($picFile->getPathname());
}
$path = $picFile->move($this->targetPath . "/" . $event->getId(), $picFile->getClientOriginalName());
$pic = new Pic();
$pic->setUrl(str_replace($this->targetPath, $this->targetUrl, $path));
$pic->setPath($path);
$event->setPic($pic);
$this->dm->persist($event);
$this->dm->flush();
return $event;
}
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;
}
}
/**
* @param UploadedFile $image
* @param string $visibility
* @return $this
*/
public function store(UploadedFile $image, $visibility = Filesystem::VISIBILITY_PUBLIC)
{
$info = getimagesize($image->getPathname());
$this->width = $info[0];
$this->height = $info[1];
$this->cloud->put($this->path, file_get_contents($image), $visibility);
return $this;
}
/**
* Physically deletes the file
* @return bool
*/
public function remove()
{
if (file_exists($this->photoUpload->getPathname())) {
unlink($this->photoUpload->getPathname());
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
protected function doUpload(PropertyMapping $mapping, UploadedFile $file, $dir, $name)
{
$filesystem = $this->getFilesystem($mapping);
$path = !empty($dir) ? $dir . '/' . $name : $name;
if ($filesystem->getAdapter() instanceof MetadataSupporter) {
$filesystem->getAdapter()->setMetadata($path, array('contentType' => $file->getMimeType()));
}
$filesystem->write($path, file_get_contents($file->getPathname()), true);
}
/**
* Add a material from a file into the multimediaObject
*/
public function addMaterialFile(MultimediaObject $multimediaObject, UploadedFile $materialFile, $formData)
{
if (UPLOAD_ERR_OK != $materialFile->getError()) {
throw new \Exception($materialFile->getErrorMessage());
}
if (!is_file($materialFile->getPathname())) {
throw new FileNotFoundException($materialFile->getPathname());
}
$material = new Material();
$material = $this->saveFormData($material, $formData);
$path = $materialFile->move($this->targetPath . "/" . $multimediaObject->getId(), $materialFile->getClientOriginalName());
$material->setPath($path);
$material->setUrl(str_replace($this->targetPath, $this->targetUrl, $path));
$multimediaObject->addMaterial($material);
$this->dm->persist($multimediaObject);
$this->dm->flush();
return $multimediaObject;
}
public function upload(UploadedFile $file)
{
if (!in_array($file->getMimeType(), $this->allowedMimeTypes)) {
throw new \InvalidArgumentException(sprintf('Files of type %s are not allowed.', $file->getMimeType()));
}
$filename = sprintf('%s/%s/%s/%s.%s', date('Y'), date('m'), date('d'), uniqid(), $file->getClientOriginalExtension());
$adapter = $this->filesystem->getAdapter();
$adapter->setMetadata($filename, array('contentType' => $file->getMimeType()));
$adapter->write($filename, file_get_contents($file->getPathname()));
return $adapter->getUrl($filename);
}
public function upload(UploadedFile $file, $path)
{
// Check if the file's mime type is in the list of allowed mime types.
if (!in_array($file->getClientMimeType(), self::$allowedMimeTypes)) {
throw new \InvalidArgumentException(sprintf('Files of type %s are not allowed.', $file->getClientMimeType()));
}
$adapter = $this->filesystem->getAdapter();
$adapter->setMetadata($path, array('contentType' => $file->getClientMimeType()));
$adapter->write($path, file_get_contents($file->getPathname()));
return $path;
}
protected function uploadFile(UploadedFile $file)
{
$web_path = '/uploads/fc_request/' . date('Y/m/d');
$directory = rtrim(__DIR__, '/') . '/../../../../../../../../../web' . $web_path;
$name = $file->getClientOriginalName();
@mkdir($directory, 0777, true);
if (!@copy($file->getPathname(), $directory . '/' . $name)) {
return null;
}
return $web_path . '/' . $name;
}
/**
* @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;
}
/**
* Resize user avatar from uploaded picture
* @param \Symfony\Component\HttpFoundation\File\UploadedFile|\Symfony\Component\HttpFoundation\File\File $original
* @param int $user_id
* @param string $size
* @throws \Exception
* @return null
*/
public function resizeAndSave($original, $user_id, $size = 'small')
{
$sizeConvert = ['big' => [400, 400], 'medium' => [200, 200], 'small' => [100, 100]];
if (!array_key_exists($size, $sizeConvert)) {
return null;
}
$image = new Image();
$image->setCacheDir(root . '/Private/Cache/images');
$image->open($original->getPathname())->cropResize($sizeConvert[$size][0], $sizeConvert[$size][1])->save(root . '/upload/user/avatar/' . $size . '/' . $user_id . '.jpg', 'jpg', static::COMPRESS_QUALITY);
return null;
}
public function uploadLicenceFile()
{
if (!$this->hasLicenceFile()) {
return false;
}
$licencePath = $this->getAbsoluteDir() . '/serverkey.dat';
$filepath = $this->licenceFile->getPathname();
$content = file_get_contents($filepath);
@unlink($filepath);
unset($this->licenceFile);
return $this->getMachine()->getConnection()->upload($licencePath, $content, 0750);
}
/**
* Build a \Torann\MediaSort\File\UploadedFile object from
* a Symfony\Component\HttpFoundation\File\UploadedFile object.
*
* @param \Symfony\Component\HttpFoundation\File\UploadedFile $file
*
* @return \Torann\MediaSort\File\UploadedFile
* @throws \Torann\MediaSort\Exceptions\FileException
*/
protected function createFromObject(SymfonyUploadedFile $file)
{
$path = $file->getPathname();
$originalName = $file->getClientOriginalName();
$mimeType = $file->getClientMimeType();
$size = $file->getClientSize();
$error = $file->getError();
$uploadFile = new UploadedFile($path, $originalName, $mimeType, $size, $error);
if (!$uploadFile->isValid()) {
throw new FileException($uploadFile->getErrorMessage($uploadFile->getError()));
}
return $uploadFile;
}
/**
* Set a pic from an url into the series
*/
public function addPicFile(Series $series, UploadedFile $picFile, $isBanner = false, $bannerTargetUrl = "")
{
if (UPLOAD_ERR_OK != $picFile->getError()) {
throw new \Exception($picFile->getErrorMessage());
}
if (!is_file($picFile->getPathname())) {
throw new FileNotFoundException($picFile->getPathname());
}
$path = $picFile->move($this->targetPath . "/" . $series->getId(), $picFile->getClientOriginalName());
$pic = new Pic();
$pic->setUrl(str_replace($this->targetPath, $this->targetUrl, $path));
$pic->setPath($path);
if ($isBanner) {
$pic->setHide(true);
$pic->addTag('banner');
$series = $this->addBanner($series, $pic->getUrl(), $bannerTargetUrl);
}
// TODO: add pic the latest if it is banner
$series->addPic($pic);
$this->dm->persist($series);
$this->dm->flush();
return $series;
}
/**
* {@inheritDoc}
*/
protected function doUpload(UploadedFile $file, $dir, $name)
{
$adapter = $this->getAdapter($dir);
$src = new Local($file->getPathname());
$dst = $adapter->createFileStream($name);
$src->open(new StreamMode('rb+'));
$dst->open(new StreamMode('ab+'));
while (!$src->eof()) {
$data = $src->read(100000);
$written = $dst->write($data);
}
$dst->close();
$src->close();
}
protected function appendData($filePathPartial, UploadedFile $file)
{
if (!($out = @fopen($filePathPartial, "ab"))) {
throw new Exception("Failed to open output stream.", 102);
}
if (!($in = @fopen($file->getPathname(), "rb"))) {
throw new Exception("Failed to open input stream", 101);
}
while ($buff = fread($in, 4096)) {
fwrite($out, $buff);
}
@fclose($out);
@fclose($in);
}
/**
* Upload method
*
* @param UploadedFile $file file to upload
*
* @return string
* @throws \InvalidArgumentException
*/
public function upload(UploadedFile $file)
{
$fileMimeType = $file->getClientMimeType();
if ($this->allowedTypes && !in_array($fileMimeType, $this->allowedTypes)) {
throw new \InvalidArgumentException(sprintf('Files of type %s are not allowed.', $fileMimeType));
}
$filename = $this->generateNameByOriginal($file->getClientOriginalName());
$adapter = $this->filesystem->getAdapter();
if (!$adapter instanceof Local) {
$adapter->setMetadata($filename, ['contentType' => $fileMimeType]);
}
$adapter->write($filename, file_get_contents($file->getPathname()));
return $filename;
}
/**
* Accepts an uploaded file and fills out the details into an Attachment object.
*
* @param UploadedFile $file
* @param AttachmentInterface $attachment
* @return \Symfony\Component\HttpFoundation\File\File
*/
public function acceptUpload(UploadedFile $file, AttachmentInterface $attachment)
{
$hash = sha1_file($file->getPathname());
$name = $this->pathHelper->getName($file, $attachment, $hash);
$filename = $this->sanitiser->sanitiseFilename($file->getClientOriginalName());
$mimeType = $this->sanitiser->sanitiseMimeType($file->getClientMimeType());
$attachment->setFilename($filename);
$attachment->setFileHash($hash);
$attachment->setFileSize(filesize($file->getPathname()));
$attachment->setMimeType($mimeType);
$attachment->setPhysicalName($name);
$fullPath = sprintf('%s/%s', $this->pathHelper->getSaveDir($attachment), $name);
return $file->move(dirname($fullPath), basename($fullPath));
}
private function appendData($filePathPartial, UploadedFile $file)
{
if (!($out = @fopen($filePathPartial, 'ab'))) {
throw new PluploadException('Failed to open output stream.', 102);
}
if (!($in = @fopen($file->getPathname(), 'rb'))) {
throw new PluploadException('Failed to open input stream', 101);
}
while ($buff = fread($in, 4096)) {
fwrite($out, $buff);
}
@fclose($out);
@fclose($in);
}
/**
* {@inheritdoc}
*/
public function canUpload(UploadedFile $file)
{
$mimeType = $file->getMimeType();
if (in_array($mimeType, $this->getSupportedMimeTypes())) {
return 5;
}
if ($file->getMimeType() == 'application/ogg') {
// This could be a video or audio file.
$meta = GenericMetadataReader::readMetadata($file->getPathname());
if (isset($meta['audio']['dataformat'])) {
return 5;
}
}
return 0;
}
/**
* generate image name
*
* @param UploadedFile $imageFile
* @param string $prefix
* @return array
*/
protected function moveImage($imageFile, $prefix)
{
// destinationName
$destinationPath = public_path('resource\\' . $prefix);
// checkImage and get type
$type = $this->checkImage($imageFile->getPathname());
// generate image name
$imageName = $this->generateImageName($prefix, $type);
// move image to destination
$movedImageFile = $imageFile->move($destinationPath, $imageName);
// get movedImageFilePathname
$movedImagePathname = $movedImageFile->getPathname();
// url
$movedImageUrl = url('resource/' . "{$prefix}/" . $imageName);
return ['imgPathname' => $movedImagePathname, 'imgUrl' => $movedImageUrl];
}
public function upload(UploadedFile $file, $path = null)
{
// Check if the file's mime type is in the list of allowed mime types.
if (!in_array($file->getClientMimeType(), self::$allowedMimeTypes)) {
throw new \InvalidArgumentException(sprintf('Files of type %s are not allowed.', $file->getClientMimeType()));
}
if ($path) {
$filename = sprintf('%s/%s.%s', $path, md5(time() * rand(0, 99)), $file->getClientOriginalExtension());
} else {
$filename = sprintf('%s/%s/%s/%s.%s', date('Y'), date('m'), date('d'), md5(time() * rand(0, 99)), $file->getClientOriginalExtension());
}
$adapter = $this->filesystem->getAdapter();
$adapter->setMetadata($filename, array('contentType' => $file->getClientMimeType()));
$adapter->write($filename, file_get_contents($file->getPathname()));
return $filename;
}
/**
* Upload the photo
*
* @return boolean
*/
public function upload()
{
$rootDir = __DIR__ . '/../../../../../web/uploads/apps';
/*
* Upload and resize
*/
$imagine = new Imagine();
// Create the logo thumbnail in a 200x200 box
if (null === $this->file) {
$thumbnail = $imagine->open($rootDir . '/default.png')->thumbnail(new Box(200, 200), Image::THUMBNAIL_OUTBOUND);
} else {
$thumbnail = $imagine->open($this->file->getPathname())->thumbnail(new Box(200, 200), Image::THUMBNAIL_OUTBOUND);
}
// Save the result
$thumbnail->save($rootDir . '/' . $this->getClientId() . '.png');
}
/**
* {@inheritDoc}
*/
protected function doUpload(PropertyMapping $mapping, UploadedFile $file, $dir, $name)
{
$filesystem = $this->getFilesystem($mapping);
if ($filesystem->getAdapter() instanceof MetadataSupporter) {
$filesystem->getAdapter()->setMetadata($name, array('contentType' => $file->getMimeType()));
}
$src = new LocalStream($file->getPathname());
$dst = $filesystem->createStream($dir . $name);
$src->open(new StreamMode('rb+'));
$dst->open(new StreamMode('wb+'));
while (!$src->eof()) {
$data = $src->read(100000);
$dst->write($data);
}
$dst->close();
$src->close();
}
/**
* @param int $blur
* @param bool $darken
*
* @return File
*/
private function makeBackgroundImage($blur = 10, $darken = true)
{
$srcPath = $this->file->getPathname();
$dstFile = $this->makeTmpFile();
$dstPath = $dstFile->getPathname();
$cmd = "convert {$srcPath} -resize 1280 -gravity center";
if ($blur) {
$cmd .= " -blur {$blur},{$blur} ";
}
if ($darken) {
$cmd .= " -fill black -colorize 20%";
}
$cmd .= " {$dstPath} 2>&1";
shell_exec($cmd);
$this->optimizeJpg($dstFile);
return $dstFile;
}
/**
* File upload callback
* Resizes the image according to validation constraints
*
* @param string $field Field name
* @param Symfony\Component\HttpFoundation\File\UploadedFile $file File to process
*
* @return void
*/
protected function imageUpload($field, UploadedFile $file)
{
if (UPLOAD_ERR_OK == $file->getError()) {
$asserts = $this->getAsserts()[$field];
foreach ($asserts as $assert) {
// Detect image size constraints and resize accordingly
if ($assert instanceof Image) {
$path = $file->getPathname();
$pathWithExtension = $path . '.' . $file->guessExtension();
rename($path, $pathWithExtension);
// ImageWorkshop relies on the file's extension for encoding
try {
$this->resize($pathWithExtension, $assert->maxWidth, $assert->maxHeight);
} catch (ImageWorkshopException $e) {
}
rename($pathWithExtension, $path);
}
}
}
}
/**
* 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;
}
