public function getConfirmEmail($token) { try { $email = Crypt::decrypt($token); $userQuery = DB::table('users')->where('email', $email); $user = $userQuery->first(); if (isset($user)) { switch (\Config::get('app.registerMode')) { case 'auto': $userQuery->update(['active' => 1]); Util::flash(trans('auth.confirmed'), '', Util::ALERT_SUCCESS); // Foi enviado um email. return view('auth/login'); break; case 'confirm': $userQuery->update(['pending' => 1]); return view('info', ['title' => trans('auth.pending-approval_confirmation'), 'text' => trans('auth.pending-approval')]); break; } } else { Util::flash(trans('auth.user'), '', Util::ALERT_ERROR); } // Não existe o email. } catch (Exception $e) { Util::flash(trans('auth.token'), '', Util::ALERT_ERROR); // Token inválido. } return Redirect::action(self::HOME_ACTION); }
/** * Stream fallback delegator. * * @param string $path * @param resource $resource * @param Config $config * @param string $fallback * * @return mixed fallback result */ protected function stream($path, $resource, Config $config, $fallback) { Util::rewindStream($resource); $contents = stream_get_contents($resource); $fallbackCall = [$this, $fallback]; return call_user_func($fallbackCall, $path, $contents, $config); }
/** * @inheritdoc */ public function getSize($path) { if (!($decrypted = $this->read($path))) { return false; } $size = Util::contentSize($decrypted['contents']); return compact('path', 'size'); }
/** * {@inheritdoc} */ public function update($path, $contents, Config $config) { $location = $this->applyPathPrefix($path); $mimetype = Util::guessMimeType($path, $contents); if (($size = file_put_contents($location, $contents)) === false) { return false; } return compact('path', 'size', 'contents', 'mimetype'); }
/** * @param string $path child path to find in * * @return Finder */ public function getFinder($path = '') { $path = Util::normalizePath($path); $adapter = $this->getAdapter(); if (!$adapter instanceof FindableAdapterInterface) { throw new NotSupportedException("Adapter doesn't support getFinder action. Adapter in use is: " . get_class($adapter)); } return $adapter->getFinder($path); }
/** * Emulates touch(). * * @param string $path * * @return bool True on success, false on failure. */ public function handle($path) { $path = Util::normalizePath($path); $adapter = $this->filesystem->getAdapter(); if ($adapter->has($path)) { return true; } return (bool) $adapter->write($path, '', $this->defaultConfig()); }
/** * Write a file * * @param $path * @param $contents * @param null $config * @return array|bool */ public function write($path, $contents, $config = null) { $type = 'file'; $config = Util::ensureConfig($config); $result = compact('contents', 'type', 'size', 'path'); if ($visibility = $config->get('visibility')) { $result['visibility'] = $visibility; } return $result; }
public function rename($path, $newpath) { $location = $this->applyPathPrefix($path); $destination = $this->applyPathPrefix($newpath); $parentDirectory = $this->applyPathPrefix(Util::dirname($newpath)); if (!$this->ensureDirectory($parentDirectory)) { return false; } return rename($location, $destination); }
/** * Creates a directory. * * @param string $dirname * @param int $mode * @param int $options * * @return bool True on success, false on failure. */ public function handle($dirname, $mode, $options) { $dirname = Util::normalizePath($dirname); $adapter = $this->filesystem->getAdapter(); // If recursive, or a single level directory, just create it. if ($options & STREAM_MKDIR_RECURSIVE || strpos($dirname, '/') === false) { return (bool) $adapter->createDir($dirname, $this->defaultConfig()); } if (!$adapter->has(dirname($dirname))) { throw new FileNotFoundException($dirname); } return (bool) $adapter->createDir($dirname, $this->defaultConfig()); }
/** * Checks that a rename is valid. * * @param string $source * @param string $dest * * @return bool */ protected function isValidRename($source, $dest) { $adapter = $this->filesystem->getAdapter(); if (!$adapter->has($source)) { throw new FileNotFoundException($source); } $subdir = Util::dirname($dest); if (strlen($subdir) && !$adapter->has($subdir)) { throw new FileNotFoundException($source); } if (!$adapter->has($dest)) { return true; } return $this->compareTypes($source, $dest); }
/** * {@inheritdoc} */ public function storeContents($directory, array $contents, $recursive) { if ($recursive) { return $contents; } foreach ($contents as $index => $object) { $pathinfo = Util::pathinfo($object['path']); $object = array_merge($pathinfo, $object); if (!$recursive && $object['dirname'] !== $directory) { unset($contents[$index]); continue; } $contents[$index] = $object; } return $contents; }
/** * Delete a directory. * * @param string $dirname path to directory * @param int $options * * @return bool */ public function handle($dirname, $options) { $dirname = Util::normalizePath($dirname); if ($dirname === '') { throw new RootViolationException('Root directories can not be deleted.'); } $adapter = $this->filesystem->getAdapter(); if ($options & STREAM_MKDIR_RECURSIVE) { // I don't know how this gets triggered. return (bool) $adapter->deleteDir($dirname); } $contents = $this->filesystem->listContents($dirname); if (!empty($contents)) { throw new DirectoryNotEmptyException(); } return (bool) $adapter->deleteDir($dirname); }
/** * Use flysystem to save the file in the desired location. * * @param \Onema\ClassyFile\Event\GetClassEvent $event */ public function onGetClassGenerateFile(GetClassEvent $event) { $statement = $event->getStatements(); $fileLocation = $event->getFileLocation(); $code = $event->getCode(); $name = $statement->name; if (!$this->filesystem->has($fileLocation)) { // dir doesn't exist, make it $this->filesystem->createDir($fileLocation); } $location = sprintf('%s/%s.php', $fileLocation, $name); $this->filesystem->put($location, $code); $adapter = $this->filesystem->getAdapter(); if ($adapter instanceof AbstractAdapter) { $prefix = $adapter->getPathPrefix(); $location = Util::normalizePath($location); $event->setFileLocation(sprintf('%s%s', $prefix, $location)); } }
/** * Write a new file. * * @param string $path * @param string $contents * @param Config $config Config object * @return array|false false on failure file meta data on success */ public function write($path, $contents, Config $config = null) { $tmpFile = tempnam(sys_get_temp_dir(), 'arconnect-static'); file_put_contents($tmpFile, $contents); $file = new \CURLFile($tmpFile, Util::guessMimeType($path, $tmpFile), basename($tmpFile)); $data = ['slug' => $path, 'file' => $file]; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $this->apiUrl . '/' . $this->application); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $data); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_exec($ch); $fileInfo = curl_getinfo($ch); curl_close($ch); unlink($tmpFile); if ($fileInfo['http_code'] >= 200 && $fileInfo['http_code'] < 400) { $response = ['contents' => $contents, 'type' => $fileInfo['content_type'], 'size' => $fileInfo['size_download'], 'path' => $path]; return $response; } return false; }
/** * Determine if this stream is seekable * * @param resource $stream * @return bool True if this stream is seekable */ protected function isSeekableStream($stream) { return Util::isSeekableStream($stream); }
/** * Builds the normalized output array from a Blob object. * * @param string $path * @param BlobProperties $properties * * @return array */ protected function normalizeBlobProperties($path, BlobProperties $properties) { return ['path' => $path, 'timestamp' => (int) $properties->getLastModified()->format('U'), 'dirname' => Util::dirname($path), 'mimetype' => $properties->getContentType(), 'size' => $properties->getContentLength(), 'type' => 'file']; }
/** * {@inheritdoc} */ protected function normalizeObject(DataObject $object) { $name = $object->getName(); $name = $this->removePathPrefix($name); $mimetype = explode('; ', $object->getContentType()); return ['type' => in_array('application/directory', $mimetype) ? 'dir' : 'file', 'dirname' => Util::dirname($name), 'path' => $name, 'timestamp' => strtotime($object->getLastModified()), 'mimetype' => reset($mimetype), 'size' => $object->getContentLength()]; }
/** * @inheritdoc */ public function writeStream($path, $resource, Config $config) { $this->ensureDirectory(Util::dirname($path)); if (!ftp_fput($this->getConnection(), $path, $resource, $this->transferMode)) { return false; } if ($visibility = $config->get('visibility')) { $this->setVisibility($path, $visibility); } return compact('path', 'visibility'); }
/** * Normalize the object result array. * * @param array $response * @param string $path * * @return array */ protected function normalizeResponse(array $response, $path = null) { $result = ['path' => $path ?: $this->removePathPrefix($response['Key'])]; $result = array_merge($result, Util::pathinfo($result['path'])); if (isset($response['LastModified'])) { $result['timestamp'] = strtotime($response['LastModified']); } if (substr($result['path'], -1) === '/') { $result['type'] = 'dir'; $result['path'] = rtrim($result['path'], '/'); return $result; } return array_merge($result, Util::map($response, static::$resultMap), ['type' => 'file']); }
/** * {@inheritdoc} */ public function get($path, Handler $handler = null) { $path = Util::normalizePath($path); if (!$handler) { $metadata = $this->getMetadata($path); $handler = $metadata['type'] === 'file' ? new File($this, $path) : new Directory($this, $path); } $handler->setPath($path); $handler->setFilesystem($this); return $handler; }
/** * Normalize a result from AWS * * @param string $object * @param string $path * @return array file metadata */ protected function normalizeObject($object, $path = null) { $result = array('path' => $path ?: $object['Key']); if (isset($object['LastModified'])) { $result['timestamp'] = strtotime($object['LastModified']); } $result = array_merge($result, Util::map($object, static::$resultMap), array('type' => 'file')); $result['dirname'] = Util::dirname($result['path']); if (isset($result['contents'])) { $result['contents'] = (string) $result['contents']; } return $result; }
/** * Join dir name and file name and return full path * * @param string $dir * @param string $name * @return string * @author Dmitry (dio) Levashov **/ protected function _joinPath($dir, $name) { return Util::normalizePath($dir . $this->separator . $name); }
/** * Normalize a result from Copy. * * @param stdClass $object * @param string $path * * @return array|false file metadata */ protected function normalizeObject($object, $path) { if (!$object instanceof stdClass) { return false; } if (isset($object->modified_time)) { $timestamp = $object->modified_time; } $path = trim($this->removePathPrefix($path), '/'); $result = Util::map((array) $object, static::$resultMap); return compact('timestamp', 'path') + $result; }
/** * {@inheritdoc} */ public function getRealPathName($file) { return Util::normalizePath($file); }
/** * Ensure parent directories of an object * * @param string $path object path */ public function ensureParentDirectories($path) { $object = $this->cache[$path]; while ($object['dirname'] !== '' && !isset($this->cache[$object['dirname']])) { $object = Util::pathinfo($object['dirname']); $object['type'] = 'dir'; $this->cache[$object['path']] = $object; } }
/** * @inheritdoc */ public function getMetadata($path) { $path = Util::normalizePath($path); $this->assertPresent($path); return $this->getAdapter()->getMetadata($path); }
/** * @inheritdoc */ public function getMimetype($path) { if (!($metadata = $this->read($path))) { return false; } $metadata['mimetype'] = Util::guessMimeType($path, $metadata['contents']); return $metadata; }
/** * @param string $path * @param array $config * * @throws \LogicException * @throws \InvalidArgumentException * @throws \Exception|\Throwable * * @return MediaEntity */ protected function createFile($path, array $config) { $path = Util::normalizePath($path); $pathInfo = pathinfo($path); return (new MediaEntity())->getConnection()->transaction(function () use($path, $pathInfo, $config) { $parent = $this->ensureDirectory(dirname($path)); $media = MediaEntity::create(['hash' => array_key_exists('hash', $config) ? $config['hash'] : md5(uniqid('media', true)), 'ext' => null, 'type' => MediaEntity::TYPE_FILE, 'caption' => array_key_exists('caption ', $config) ? $config['caption'] : $pathInfo['basename'], 'parent_id' => array_key_exists('parent_id', $config) ? $config['parent_id'] : null]); $dir = dirname($media->realPath); if (@mkdir($dir, 0755, true) && !is_dir($dir)) { throw new \InvalidArgumentException(); } if ($parent) { $media->makeChildOf($parent); } else { $media->makeRoot(); } return $media; }); }
/** * @dataProvider metaGetterProvider * * @param $method * @param $key * @param $value */ public function testMetaGetters($method, $key, $value) { $cache = new Memory(); $this->assertFalse($cache->{$method}('path.txt')); $cache->updateObject('path.txt', $object = ['path' => 'path.txt', 'type' => 'file', $key => $value] + Util::pathinfo('path.txt'), true); $this->assertEquals($object, $cache->{$method}('path.txt')); $this->assertEquals($object, $cache->getMetadata('path.txt')); }
protected function normalizeObject($object, $path = null) { $result = array('path' => $path ?: ltrim($object['path'], '/')); if (isset($object['modified'])) { $result['timestamp'] = strtotime($object['modified']); } $result = array_merge($result, Util::map($object, static::$resultMap)); $result['type'] = $object['is_dir'] ? 'dir' : 'file'; return $result; }