/** * Get the decoded contents from the main composer.json file * @return object */ private function getComposerFile() { $composerFile = $this->cache->remember('app.version', 1440, function () { return $this->filesystem->get('composer.json'); }); return json_decode($composerFile); }
/** * Execute the console command. * * @return void */ public function fire() { $this->registerClassAutoloadExceptions(); $bindings = array(); foreach ($this->getAbstracts() as $abstract) { // Validator and seeder cause problems if (in_array($abstract, ['validator', 'seeder'])) { continue; } try { $concrete = $this->laravel->make($abstract); if (is_object($concrete)) { $class = get_class($concrete); if (strpos($class, 'Proxy_') === 0) { $class = get_parent_class($class); } $bindings[$abstract] = $class; } } catch (\Exception $e) { if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) { $this->comment("Cannot make '{$abstract}': " . $e->getMessage()); } } } $content = $this->view->make('ide-helper::meta', ['bindings' => $bindings, 'methods' => $this->methods])->render(); $filename = $this->option('filename'); $written = $this->files->put($filename, $content); if ($written !== false) { $this->info("A new meta file was written to {$filename}"); } else { $this->error("The meta file could not be created at {$filename}"); } }
public function contribute(Filesystem $fs) { $markdown = $fs->get('providers/CONTRIBUTING.md'); $markdown = preg_replace('/^.+\\n/', '', $markdown); $html = \Parsedown::instance()->parse($markdown); return view('contribute', compact('html')); }
/** * @param NewImageEvent $event */ private function transferImageFiles(NewImageEvent $event) { $preProcessed = $this->imagePreProcessor->preProcess($event->image()); /** @var ImagickContract $imagick */ foreach ($preProcessed as $imagick) { $this->publicFilesystem->getDriver()->put("image/{$imagick->getFilename()}", $imagick->getImageBlob(), self::fileConfig()); } }
/** * 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; }
/** * Get the exact installed version for the specified package. * * @param string $packageName * * @return string mixed */ public function getPackageInfo($packageName) { $composerLock = json_decode($this->finder->get('composer.lock')); foreach ($composerLock->packages as $package) { if ($package->name == $packageName) { return $package; } } }
public function allLinks($from) { $files = $this->filesystem->allFiles($this->getBaseDir() . DIRECTORY_SEPARATOR . $from); $links = []; foreach ($files as $key => $file) { $links[$key] = url(env('LOCAL_BASE_DIR') . DIRECTORY_SEPARATOR . $file); $files[$key] = $this->filesystem->getDriver()->getAdapter()->getPathPrefix() . $files[$key]; } return ['files' => $files, 'links' => $links]; }
/** * Write messages to build log. * * @param \KevinDierkx\Muse\Events\Console\Satis\WriteEventInterface $event * @return bool */ protected function writeToLog(WriteEventInterface $event) { $buildFile = 'build/build-' . $event->getBuildAt()->format('YmdHis') . '.log'; if (!$event->getNewline()) { return false; } if (is_array($messages = $event->getMessages())) { return $this->storage->append($buildFile, implode(PHP_EOL, $event->getMessages())); } return $this->storage->append($buildFile, $messages); }
/** * Deletes the current attachment as well as the file. * * @param Filesystem $filesystem * * @throws \Exception * * @return bool */ public function handle(Filesystem $filesystem) { try { if ($filesystem->delete($this->attachment->getStorageFilePath())) { return $this->attachment->delete(); } } catch (FileNotFoundException $e) { // } return false; }
/** * Get the hydrated models. * * @param array $files * @return \Illuminate\Support\Collection */ protected function getModels(array $files) { $collection = new Collection(); foreach ($files as $path) { if (strpos($path, 'build-') !== false) { $contents = $this->storage->get($path); $collection->push($this->createModel(['path' => $path])); } } return $collection; }
/** * Write the PDF * * @param string $template * @param array $data * @return string */ public function write($template, array $data) { $filename = sprintf('export-%s.pdf', time()); $this->storage->put($filename, view($template, $data)); $path = storage_path(sprintf('app/%s', $filename)); $phantom = base_path('bin/phantom/phantomjs'); $config = base_path('bin/phantom/config.js'); $command = sprintf('%s —ssl-protocol=any %s %s', $phantom, $config, $path); $process = (new Process($command, __DIR__))->setTimeout(10)->mustRun(); return $path; }
/** * @param \Codex\Codex\Project $project * @param Filesystem $files * @param \Illuminate\Contracts\Cache\Repository $cache * @param string $path * @return void * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException */ public function __construct(Project $project, Filesystem $files, Cache $cache, $path) { $this->cache = $cache; $this->files = $files; $this->path = $path; $this->project = $project; Factory::run('menu:ready', [$this]); $this->raw = $files->get($path); $this->menu = $this->parse($this->raw); Factory::run('menu:done', [$this]); }
/** * @return string */ public function make() : string { $fields = array_keys(Entry::getFieldsAndTypes()); $types = Entry::getFieldsAndTypes(); $configuration = ['date-format' => 'Y-m-d', 'has-headers' => true, 'map' => [], 'roles' => [], 'mapped' => [], 'specifix' => []]; foreach ($fields as $field) { $configuration['roles'][] = $types[$field]; } $file = $this->job->key . '-configuration.json'; $this->exportDisk->put($file, json_encode($configuration, JSON_PRETTY_PRINT)); return $file; }
public function isReachable() : bool { if (is_null($this->disk)) { return false; } try { $this->disk->allFiles($this->backupName); return true; } catch (Exception $exception) { $this->connectionError = $exception; return false; } }
/** * @param Filesystem $filesystem * @param Repository $config * @return CommandResult */ public function handle(Filesystem $filesystem, Repository $config) { $path = is_null($this->path) ? DIRECTORY_SEPARATOR : $this->path; $response = []; $response['files'] = $filesystem->files($path); $response['directories'] = $filesystem->directories($path); $response['base_path'] = $config->get('filesystems.disks.local.root'); $response['paths'] = $this->breakDownPath($path); $response['current_path'] = $this->path; $response['is_empty'] = $this->isResultIsEmpty($response['files'], $response['directories']); // all good return new CommandResult(true, "List command successful.", $response, 200); }
protected function loadConfig(Filesystem $fs, $scraperDir) { $scraperConfigFile = $scraperDir . '/scraper.yml'; if (!$fs->exists($scraperConfigFile)) { return null; } $configString = $fs->get($scraperConfigFile); $parser = new Parser(); $config = $parser->parse($configString); if (!is_array($config) || !count($config) >= 2) { return null; } return $config; }
/** * Store a newly created resource in storage. * * @return Response */ public function store(ValidaInscripcionRequest $request, Filesystem $filesystem) { //Obtengo la foto del request que envia el usuario $file1 = $request->file('foto1'); $file2 = $request->file('foto2'); $file3 = $request->file('foto3'); //obtengo las extensiones $extension1 = explode(".", $file1->getClientOriginalName()); $extension2 = explode(".", $file2->getClientOriginalName()); $extension3 = explode(".", $file3->getClientOriginalName()); //armo los nombres $nombre1 = $request->persona_id . '_frente.' . $extension1[1]; $nombre2 = $request->persona_id . '_perfil.' . $extension1[1]; $nombre3 = $request->persona_id . '_carnaval.' . $extension1[1]; //valido y guardo el archivo en el disco if ($file1->isValid()) { $stream = fopen($file1->getRealPath(), 'r+'); $filesystem->writeStream($nombre1, $stream); fclose($stream); } if ($file2->isValid()) { $stream = fopen($file2->getRealPath(), 'r+'); $filesystem->writeStream($nombre2, $stream); fclose($stream); } if ($file3->isValid()) { $stream = fopen($file3->getRealPath(), 'r+'); $filesystem->writeStream($nombre3, $stream); fclose($stream); } //busco la persona y grabo los datos en la base $persona = Persona::find($request->persona_id); $persona->fill($request->all()); $persona->foto1 = $request->persona_id . '_frente'; $persona->foto2 = $request->persona_id . '_perfil'; $persona->foto3 = $request->persona_id . '_carnaval'; $persona->status = true; //status en true es para que no vuelva a modificar $persona->save(); //envio el correo Mail::send('mails.cuerpo', $request->all(), function ($msj) use($persona, $extension1, $extension2, $extension3) { $msj->subject('Inscripcion Mari - Mari 2016 '); $msj->to('*****@*****.**'); $msj->cc('*****@*****.**', "Javier Parra"); $msj->attach(storage_path() . '/app/fotos/' . $persona->id . "_perfil." . $extension1[1]); $msj->attach(storage_path() . '/app/fotos/' . $persona->id . "_frente." . $extension2[1]); $msj->attach(storage_path() . '/app/fotos/' . $persona->id . "_carnaval." . $extension3[1]); }); return view('new')->with('email', $persona->email); }
/** * @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); }
/** * * @param UploadedFile $file * @param Model $model * * @return Attachment */ protected function processFile(UploadedFile $file, Model $model) : Attachment { $validation = $this->validateUpload($file, $model); if ($validation === false) { return new Attachment(); } $attachment = new Attachment(); // create Attachment object. $attachment->user()->associate(auth()->user()); $attachment->attachable()->associate($model); $attachment->md5 = md5_file($file->getRealPath()); $attachment->filename = $file->getClientOriginalName(); $attachment->mime = $file->getMimeType(); $attachment->size = $file->getSize(); $attachment->uploaded = 0; $attachment->save(); $fileObject = $file->openFile('r'); $fileObject->rewind(); $content = $fileObject->fread($file->getSize()); $encrypted = Crypt::encrypt($content); // store it: $this->uploadDisk->put($attachment->fileName(), $encrypted); $attachment->uploaded = 1; // update attachment $attachment->save(); $name = e($file->getClientOriginalName()); // add message: $msg = (string) trans('validation.file_attached', ['name' => $name]); $this->messages->add('attachments', $msg); // return it. return $attachment; }
/** * 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 \Illuminate\Http\UploadedFile $file * @param array $configs * @return array */ public function handle($file, $configs = []) { if (is_array($file)) { $jsonFormatDataArr = []; foreach ($file as $uploadedFile) { $jsonFormatDataArr[] = $this->handle($uploadedFile, $configs); } return $jsonFormatDataArr; } else { try { $configs = array_merge($this->configs, $configs); if (is_null($file)) { throw new UploadFileException('Upload file can not be null!'); } if (!$this->isUploadedFile($file)) { throw new UploadFileException('Upload file is not a \\Illuminate\\Http\\UploadedFile instance!'); } $jsonFormatData = $this->getJosnFormatData($file); if (!$this->isValidUploadFileSize($jsonFormatData['size'], $configs['max_size'])) { throw new UploadFileException('The upload file may not be greater than ' . $this->size2mb($configs['max_size']) . '.'); } if (!$this->isValidUploadFileExtension($jsonFormatData['extension'], $configs['extensions'])) { throw new UploadFileException("The upload file suffix may only " . implode(', ', $configs['extensions']) . '.'); } if (!$this->isValidUploadFileMimeType($jsonFormatData['mime_type'], $configs['mime_types'])) { throw new UploadFileException('The upload file mime-type may only ' . implode(', ', $configs['mime_types']) . '.'); } $jsonFormatData['savename'] = $this->makeFilename($file); $jsonFormatData['savepath'] = $this->getSavepath($configs['directory'], $configs['timestamps']); if (empty($jsonFormatData['savepath'])) { $jsonFormatData['fullpath'] = $jsonFormatData['savename']; } else { $jsonFormatData['fullpath'] = "{$jsonFormatData['savepath']}/{$jsonFormatData['savename']}"; } $result = $this->filesystem->put($jsonFormatData['fullpath'], file_get_contents($file->getRealPath())); if (!$result) { throw new UploadFileException('Unknown reason cause upload failed!'); } $jsonFormatData['status'] = 'success'; } catch (UploadFileException $e) { $jsonFormatData['status'] = 'failure'; $jsonFormatData['error'] = $e->getMessage(); } return $jsonFormatData; } }
/** * @param Filesystem $filesystem * @return CommandResult */ public function handle(Filesystem $filesystem) { // check if user has permission if (!$this->disablePermissionChecking) { if (!$this->user->hasAnyPermission(['media.delete'])) { return new CommandResult(false, "Not enough permission.", null, 403); } } if (is_null($this->paths)) { return new CommandResult(false, "No file path given.", null, 400); } // begin delete if (!$filesystem->delete($this->paths)) { return new CommandResult(false, "Failed to delete file.", null, 400); } // all good return new CommandResult(true, "File(s) successfully deleted.", null, 200); }
/** * Execute the console command. * * @return mixed */ public function handle() { if ($this->option('filter')) { $this->filesystem->deleteDirectory(config('image-service.path') . '/' . $this->option('filter')); $this->info('Deleted all cached images for "' . $this->option('filter') . '" filter.'); } elseif ($this->option('cached')) { foreach ($this->filesystem->directories(config('image-service.path')) as $dir) { // don't delete the original source image if (!preg_match("/original\$/mi", $dir)) { $this->filesystem->deleteDirectory($dir); } } $this->info('Deleted all cached images.'); } else { $this->filesystem->deleteDirectory(config('image-service.path')); $this->info('All images has been deleted.'); } }
/** * Delete a single file from request. * * @param \Illuminate\Http\Request $request * @return \Illuminate\Http\JsonResponse */ protected function deleteFile(Request $request) { try { $file = $request->input('s'); $this->storage->delete($file); return $this->notifySuccess($file . ' successfully deleted!'); } catch (\ErrorException $e) { return $this->notifyError($e->getMessage()); } }
/** * Execute the console command. * * @return void */ public function fire() { $bindings = array(); foreach ($this->getAbstracts() as $abstract) { try { $concrete = $this->laravel->make($abstract); if (is_object($concrete)) { $bindings[$abstract] = get_class($concrete); } } catch (\Exception $e) { $this->error("Cannot make {$abstract}: " . $e->getMessage()); } } $content = $this->view->make('ide-helper::meta', ['bindings' => $bindings, 'methods' => $this->methods])->render(); $filename = $this->option('filename'); $written = $this->files->put($filename, $content); if ($written !== false) { $this->info("A new meta file was written to {$filename}"); } else { $this->error("The meta file could not be created at {$filename}"); } }
/** * @param Filesystem $filesystem * @return CommandResult */ public function handle(Filesystem $filesystem) { // check if user has permission if (!$this->disablePermissionChecking) { if (!$this->user->hasAnyPermission(['media.delete'])) { return new CommandResult(false, "Not enough permission.", null, 403); } } if (is_null($this->paths)) { return new CommandResult(false, "No file path given.", null, 400); } // begin delete if (is_array($this->paths)) { foreach ($this->paths as $dir) { $filesystem->deleteDirectory($dir); } } else { $filesystem->deleteDirectory($this->paths); } // all good return new CommandResult(true, "directories successfully deleted.", null, 200); }
/** * @param $fs Filesystem * @param $scrapers Collection **/ protected function processChunk(Filesystem $fs, Collection $scrapers) { $lastJob = 0; if ($fs->exists('lastScraperRun')) { $lastJob = $fs->get('lastScraperRun'); } $scrapers->slice($lastJob, self::JOBS_PER_CALL); $this->scheduleScrapers($scrapers); $nextJob = 0; if ($lastJob + self::JOBS_PER_CALL > $scrapers->count()) { $nextJob = $lastJob + self::JOBS_PER_CALL; } $fs->put('lastScraperRun', $nextJob); }
/** * Uploads and attaches files for the current relation. * * @param Filesystem $filesystem * * @return bool|array */ public function handle(Filesystem $filesystem) { $files = $this->request->file('files'); if (is_array($files)) { $uploaded = []; foreach ($files as $file) { // Double check that we have an uploaded file instance. if ($file instanceof UploadedFile) { // Generates the unique file name. $name = implode('.', [uuid(), $file->getClientOriginalExtension()]); // Generates the complete storage path. $path = implode(DIRECTORY_SEPARATOR, [$this->path, $name]); // Try and move the uploaded file into storage. if ($filesystem->put($path, file_get_contents($file->getRealPath()))) { // Successfully moved uploaded file, create the record. $attributes = ['user_id' => auth()->id(), 'name' => $file->getClientOriginalName(), 'file_name' => $name, 'file_path' => $path]; $uploaded[] = $this->relation->create($attributes); } } } return $uploaded; } return false; }
/** * @param string $entry */ private function saveOldImportFile(string $entry) { $content = ''; try { $content = Crypt::decrypt($this->uploadDisk->get($entry)); } catch (DecryptException $e) { Log::error('Could not decrypt old CSV import file ' . $entry . '. Skipped because ' . $e->getMessage()); } if (strlen($content) > 0) { // add to export disk. $date = $this->getOriginalUploadDate($entry); $file = $this->job->key . '-Old import dated ' . $date . '.csv'; $this->exportDisk->put($file, $content); $this->getFiles()->push($file); } }
/** * @param Attachment $attachment * * @return bool */ private function exportAttachment(Attachment $attachment) : bool { $file = $attachment->fileName(); if ($this->uploadDisk->exists($file)) { try { $decrypted = Crypt::decrypt($this->uploadDisk->get($file)); $exportFile = $this->exportFileName($attachment); $this->exportDisk->put($exportFile, $decrypted); $this->getFiles()->push($exportFile); // explain: $this->explain($attachment); } catch (DecryptException $e) { Log::error('Catchable error: could not decrypt attachment #' . $attachment->id . ' because: ' . $e->getMessage()); } } return true; }