/**
* Validate that the storage directory exists. If it does not, create it.
*
* @return bool
*/
public function validateStoragePath()
{
if (!$this->files->exists($this->storage)) {
return $this->files->makeDirectory($this->storage);
}
return true;
}
/**
* Get chuck upload path.
*
* @return string
*/
public function getChunkPath()
{
$path = $this->app['config']->get('plupload.chunk_path');
if (!$this->storage->isDirectory($path)) {
$this->storage->makeDirectory($path, 0777, true);
}
return $path;
}
/**
* Return the directory where all files of the given media are stored.
*
* @param \Spatie\MediaLibrary\Media $media
*
* @return string
*/
public function getMediaDirectory(Media $media)
{
$this->disk->put('.gitignore', Gitignore::getContents());
$directory = $media->id;
$this->disk->makeDirectory($directory);
$this->disk->makeDirectory($directory . '/conversions');
return $directory;
}
/**
* create filtered image
*
* @param string $hash
* @param string $filename
* @param string[]|string $filters
* @return void
*/
public function create($hash, $filename, $filters)
{
$filteredImages = [];
$imageContent = $this->filesystem->get(config('image-service.path') . '/original/' . $hash . '/' . $filename);
$image = $this->imageManager->make($imageContent);
// if just one filter as string
if (is_string($filters)) {
$filters = [$filters];
}
foreach ($filters as $filterName) {
$filterData = config('image-service.filters.' . $filterName);
/** @var Filter $filter */
$filter = app('image.filters.' . $filterData['type']);
$filteredImage = $filter->process($image, isset($filterData['options']) ? $filterData['options'] : []);
// cache if needed
if (isset($filterData['cache']) && $filterData['cache'] === true) {
$filterPath = config('image-service.path') . '/' . $filterName . '/' . $hash;
$this->filesystem->makeDirectory($filterPath);
$this->filesystem->put($filterPath . '/' . $filename, $filteredImage->encode(null, 100));
}
// save to return it
$filteredImages[$filterName] = $filteredImage;
}
return $filteredImages;
}
/**
* @param Filesystem $filesystem
* @return CommandResult
*/
public function handle(Filesystem $filesystem)
{
// check if user has permission
if (!$this->disablePermissionChecking) {
if (!$this->user->hasAnyPermission(['media.manage'])) {
return new CommandResult(false, "Not enough permission.", null, 403);
}
}
$path = is_null($this->path) ? '/' : $this->path;
if (!($dir = $filesystem->makeDirectory($this->normalizePath($path) . $this->dirName))) {
return new CommandResult(false, "Failed to create directory.", null, 400);
}
// all good
return new CommandResult(true, "Make directory command successful.", array($dir), 201);
}
/**
* Create a folder.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\RedirectResponse
*/
public function addFolder(Request $request)
{
// check if public/media is the parent folder
if (strpos($request->input('current_directory'), $this->getRootDir()) === false) {
flash()->error('Invalid folder!');
return redirect()->back();
}
// check if alphanumeric and no space
if (!ctype_alnum($request->input('new_directory'))) {
flash()->error('Invalid folder name! Folder name must be alphanumeric only and no space');
return redirect()->back();
}
$this->storage->makeDirectory($request->input('current_directory') . '/' . $request->input('new_directory'));
// new current directory
$folder = $request->input('current_directory') . '/' . $request->input('new_directory');
flash()->success('New Folder added successfully!');
return redirect()->back()->with('folder', $folder);
}
/**
* Parse Filename
*
* @param UploadedFile $file Uploaded File
* @param string $name String Name
* @param string $folder String Folder
* @param bool $override Boolean Over Ride
*
* @return bool|array
*/
protected function parseFile($file, $folder = null, $name = null, $override = false)
{
$folder = trim((string) $folder, '/');
$folder = $folder ? "{$folder}/" : "";
$this->storage->makeDirectory($folder);
$name = $name ?: $file->getClientOriginalName();
$nameOriginal = str_slug(pathinfo($name, PATHINFO_FILENAME));
if (empty($nameOriginal)) {
$nameOriginal = str_random(10);
}
$extension = $file->getClientOriginalExtension();
$size = $file->getClientSize();
$mime = $file->getClientMimeType();
$sufix = '';
$count = 1;
do {
$name = "{$nameOriginal}{$sufix}.{$extension}";
$filename = "{$folder}{$name}";
$sufix = "({$count})";
$count++;
} while (!$override && $this->storage->exists($filename));
return compact('filename', 'name', 'extension', 'size', 'mime');
}
/**
* Copy the given file on the given disk to the given destination.
*
* @param string $file
* @param \Illuminate\Contracts\Filesystem\Filesystem $disk
* @param string $destination
* @param bool $addIgnoreFile
*/
protected function copyFile($file, $disk, $destination, $addIgnoreFile = false)
{
$destinationDirectory = dirname($destination);
$disk->makeDirectory($destinationDirectory);
if ($addIgnoreFile) {
$this->writeIgnoreFile($disk, $destinationDirectory);
}
/*
* The file could be quite large. Use a stream to copy it
* to the target disk to avoid memory problems
*/
$disk->getDriver()->writeStream($destination, fopen($file, 'r+'));
}
/**
* Create a directory.
*
* @param string $path
*
* @return bool
*/
public function makeDirectory($path)
{
$path = $this->getPathPrefix($path);
return $this->drive->makeDirectory($path);
}
/**
* Check if set storage path is writable
* @return void
*/
public function createDirectory($path)
{
if (!$this->storage->exists($path)) {
$this->storage->makeDirectory($path, 0755, true);
}
}
/**
* Ensure that directory exist
* @param Filesystem $filesystem
* @param string $path
* @return void
*/
protected function ensureDirectoryExist(Filesystem $filesystem, $path)
{
// Remove file name from string to get directory
$dir = implode('/', array_slice(explode('/', $path), 0, -1));
if (!$filesystem->exists($dir)) {
$filesystem->makeDirectory($dir);
}
}
public function syncRef($ref, $type)
{
$content = new GitSyncContent($this->setting('owner'), $this->setting('repository'), $this->github);
$hasDocs = $content->exists($this->setting('sync.paths.docs'), $ref);
if (!$hasDocs) {
return;
}
$destinationDir = Path::join($this->project->getPath(), $ref);
$menu = $content->show($this->setting('sync.paths.menu'), $ref);
$menuContent = base64_decode($menu['content']);
$menuArray = Yaml::parse($menuContent);
$unfilteredPages = [];
$this->extractDocumentsFromMenu($menuArray['menu'], $unfilteredPages);
$filteredPages = [];
# filter out pages that link to external sites
foreach ($unfilteredPages as $page) {
if (Str::startsWith($page, 'http', true) || Str::startsWith($page, '//', true) || Str::startsWith($page, 'git', true)) {
continue;
}
if (!in_array($page, $filteredPages, true)) {
$filteredPages[] = $page;
}
}
# get all pages their content and save to local
foreach ($filteredPages as $pagePath) {
$path = Path::join($this->setting('sync.paths.docs'), $pagePath . '.md');
# check if page exists on remote
$exists = $content->exists($path, $ref);
if (!$exists) {
continue;
}
# the raw github page content response
$pageRaw = $content->show('/' . $path, $ref);
# transform remote directory path to local directory path
$dir = Str::remove($pageRaw['path'], $this->setting('sync.paths.docs'));
$dir = Str::remove($dir, $pageRaw['name']);
$dir = Path::canonicalize(Path::join($destinationDir, $dir));
if (!$this->files->exists($dir)) {
$this->files->makeDirectory($dir);
}
# raw github page to utf8 and save it to local
$this->files->put(Path::join($dir, $pageRaw['name']), base64_decode($pageRaw['content']));
}
# save the menu to local
$this->files->put(Path::join($destinationDir, 'menu.yml'), $menuContent);
# if enabled, Get phpdoc structure and save it
if ($this->setting('phpdoc')) {
$hasStructure = $content->exists($this->setting('paths.phpdoc'), $ref);
if ($hasStructure) {
$structure = $content->show($this->setting('paths.phpdoc'), $ref);
$structureXml = base64_decode($structure['content']);
$destination = Path::join($destinationDir, 'structure.xml');
$destinationDir = Path::getDirectory($destination);
if (!$this->files->exists($destinationDir)) {
$this->files->makeDirectory($destinationDir);
}
$this->files->put($destination, $structureXml);
}
}
# set cache sha for branches, not for tags (obviously)
if ($type === 'branch') {
$branchData = $this->github->repositories()->branches($this->setting('owner'), $this->setting('repository'), $ref);
$this->cache->forever(md5($this->project->getName() . $branchData['name']), $branchData['commit']['sha']);
}
}
protected function ensureDirectory($path)
{
if (!$this->files->exists($path)) {
$this->files->makeDirectory($path);
}
}
/**
* Write the uploaded file to the local filesystem.
*
* @param \Illuminate\Http\Request $request
*
* @return \Illuminate\Http\JsonResponse
*/
public function handleUpload(Request $request)
{
$fineUploaderUuid = null;
if ($request->has('qquuid')) {
$fineUploaderUuid = $request->get('qquuid');
}
//------------------------------
// Is it Post-processing?
//------------------------------
if ($request->has('post-process') && $request->get('post-process') == 1) {
# Combine chunks.
$this->combineChunks($request);
return collect(event(new Uploaded($fineUploaderUuid, $request)))->last();
// Return the result of the second event listener.
}
//----------------
// Prelim work.
//----------------
if (!file_exists($this->temporaryChunksFolder) || !is_dir($this->temporaryChunksFolder)) {
$this->filesystem->makeDirectory($this->temporaryChunksFolder);
}
# Temp folder writable?
if (!is_writable($absolutePathToTemporaryChunksFolder = config('filesystems.disks.local.root') . $this->temporaryChunksFolder) || !is_executable($absolutePathToTemporaryChunksFolder)) {
throw new FileStreamExceptions\TemporaryUploadFolderNotWritableException();
}
# Cleanup chunks.
if (1 === mt_rand(1, 1 / $this->chunksCleanupProbability)) {
$this->cleanupChunks();
}
# Check upload size against the size-limit, if any.
if (!empty($this->sizeLimit)) {
$uploadIsTooLarge = false;
$request->has('qqtotalfilesize') && intval($request->get('qqtotalfilesize')) > $this->sizeLimit && ($uploadIsTooLarge = true);
$this->filesizeFromHumanReadableToBytes(ini_get('post_max_size')) < $this->sizeLimit && ($uploadIsTooLarge = true);
$this->filesizeFromHumanReadableToBytes(ini_get('upload_max_filesize')) < $this->sizeLimit && ($uploadIsTooLarge = true);
if ($uploadIsTooLarge) {
throw new FileStreamExceptions\UploadTooLargeException();
}
}
# Is there attempt for multiple file uploads?
$collectionOfUploadedFiles = collect($request->file());
if ($collectionOfUploadedFiles->count() > 1) {
throw new FileStreamExceptions\MultipleSimultaneousUploadsNotAllowedException();
}
/** @var UploadedFile $file */
$file = $collectionOfUploadedFiles->first();
//--------------------
// Upload handling.
//--------------------
if ($file->getSize() == 0) {
throw new FileStreamExceptions\UploadIsEmptyException();
}
$name = $file->getClientOriginalName();
if ($request->has('qqfilename')) {
$name = $request->get('qqfilename');
}
if (empty($name)) {
throw new FileStreamExceptions\UploadFilenameIsEmptyException();
}
$totalNumberOfChunks = $request->has('qqtotalparts') ? $request->get('qqtotalparts') : 1;
if ($totalNumberOfChunks > 1) {
$chunkIndex = intval($request->get('qqpartindex'));
$targetFolder = $this->temporaryChunksFolder . DIRECTORY_SEPARATOR . $fineUploaderUuid;
if (!$this->filesystem->exists($targetFolder)) {
$this->filesystem->makeDirectory($targetFolder);
}
if (!$file->isValid()) {
throw new FileStreamExceptions\UploadAttemptFailedException();
}
$file->move(storage_path('app' . $targetFolder), $chunkIndex);
return response()->json(['success' => true, 'uuid' => $fineUploaderUuid]);
} else {
if (!$file->isValid()) {
throw new FileStreamExceptions\UploadAttemptFailedException();
}
$file->move(storage_path('app'), $fineUploaderUuid);
return collect(event(new Uploaded($fineUploaderUuid, $request)))->last();
// Return the result of the second event listener.
}
}
/**
* Creates directory if it does not exists
*
* @param $directory
* @return bool
*/
protected function ensureDirectoryExistence($directory)
{
return $this->filesystem->makeDirectory($directory);
}
