Lumen IDE Helper
| <?php | |
| /** | |
| * A helper file for Laravel 5, to provide autocomplete information to your IDE | |
| * Generated for Laravel Lumen (5.1.1) (Laravel Components 5.1.*) on 2015-08-18. | |
| * | |
| * @author Barry vd. Heuvel <barryvdh@gmail.com> | |
| * @see https://github.com/barryvdh/laravel-ide-helper | |
| */ | |
| namespace { | |
| exit("This file should not be included, only analyzed by your IDE"); | |
| class App extends \Illuminate\Support\Facades\App{ | |
| /** | |
| * Get the version number of the application. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function version(){ | |
| return \Laravel\Lumen\Application::version(); | |
| } | |
| /** | |
| * Get or check the current application environment. | |
| * | |
| * @param mixed | |
| * @return string | |
| * @static | |
| */ | |
| public static function environment(){ | |
| return \Laravel\Lumen\Application::environment(); | |
| } | |
| /** | |
| * Determine if the application is currently down for maintenance. | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function isDownForMaintenance(){ | |
| return \Laravel\Lumen\Application::isDownForMaintenance(); | |
| } | |
| /** | |
| * Register all of the configured providers. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function registerConfiguredProviders(){ | |
| \Laravel\Lumen\Application::registerConfiguredProviders(); | |
| } | |
| /** | |
| * Get the path to the cached "compiled.php" file. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getCachedCompilePath(){ | |
| return \Laravel\Lumen\Application::getCachedCompilePath(); | |
| } | |
| /** | |
| * Get the path to the cached services.json file. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getCachedServicesPath(){ | |
| return \Laravel\Lumen\Application::getCachedServicesPath(); | |
| } | |
| /** | |
| * Register a service provider with the application. | |
| * | |
| * @param \Illuminate\Support\ServiceProvider|string $provider | |
| * @param array $options | |
| * @param bool $force | |
| * @return \Illuminate\Support\ServiceProvider | |
| * @static | |
| */ | |
| public static function register($provider, $options = array(), $force = false){ | |
| return \Laravel\Lumen\Application::register($provider, $options, $force); | |
| } | |
| /** | |
| * Register a deferred provider and service. | |
| * | |
| * @param string $provider | |
| * @param string $service | |
| * @return void | |
| * @static | |
| */ | |
| public static function registerDeferredProvider($provider, $service = null){ | |
| \Laravel\Lumen\Application::registerDeferredProvider($provider, $service); | |
| } | |
| /** | |
| * Boot the application's service providers. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function boot(){ | |
| \Laravel\Lumen\Application::boot(); | |
| } | |
| /** | |
| * Register a new boot listener. | |
| * | |
| * @param mixed $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function booting($callback){ | |
| \Laravel\Lumen\Application::booting($callback); | |
| } | |
| /** | |
| * Register a new "booted" listener. | |
| * | |
| * @param mixed $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function booted($callback){ | |
| \Laravel\Lumen\Application::booted($callback); | |
| } | |
| /** | |
| * Throw an HttpException with the given data. | |
| * | |
| * @param int $code | |
| * @param string $message | |
| * @param array $headers | |
| * @return void | |
| * @throws \Symfony\Component\HttpKernel\Exception\HttpException | |
| * @static | |
| */ | |
| public static function abort($code, $message = '', $headers = array()){ | |
| \Laravel\Lumen\Application::abort($code, $message, $headers); | |
| } | |
| /** | |
| * Resolve the given type from the container. | |
| * | |
| * @param string $abstract | |
| * @param array $parameters | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function make($abstract, $parameters = array()){ | |
| return \Laravel\Lumen\Application::make($abstract, $parameters); | |
| } | |
| /** | |
| * Load a configuration file into the application. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function configure($name){ | |
| \Laravel\Lumen\Application::configure($name); | |
| } | |
| /** | |
| * Register the facades for the application. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function withFacades(){ | |
| \Laravel\Lumen\Application::withFacades(); | |
| } | |
| /** | |
| * Load the Eloquent library for the application. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function withEloquent(){ | |
| \Laravel\Lumen\Application::withEloquent(); | |
| } | |
| /** | |
| * Register a set of routes with a set of shared attributes. | |
| * | |
| * @param array $attributes | |
| * @param \Closure $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function group($attributes, $callback){ | |
| \Laravel\Lumen\Application::group($attributes, $callback); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function get($uri, $action){ | |
| return \Laravel\Lumen\Application::get($uri, $action); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function post($uri, $action){ | |
| return \Laravel\Lumen\Application::post($uri, $action); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function put($uri, $action){ | |
| return \Laravel\Lumen\Application::put($uri, $action); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function patch($uri, $action){ | |
| return \Laravel\Lumen\Application::patch($uri, $action); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function delete($uri, $action){ | |
| return \Laravel\Lumen\Application::delete($uri, $action); | |
| } | |
| /** | |
| * Register a route with the application. | |
| * | |
| * @param string $uri | |
| * @param mixed $action | |
| * @return $this | |
| * @static | |
| */ | |
| public static function options($uri, $action){ | |
| return \Laravel\Lumen\Application::options($uri, $action); | |
| } | |
| /** | |
| * Add a route to the collection. | |
| * | |
| * @param string $method | |
| * @param string $uri | |
| * @param mixed $action | |
| * @static | |
| */ | |
| public static function addRoute($method, $uri, $action){ | |
| return \Laravel\Lumen\Application::addRoute($method, $uri, $action); | |
| } | |
| /** | |
| * Add new middleware to the application. | |
| * | |
| * @param array $middleware | |
| * @return $this | |
| * @static | |
| */ | |
| public static function middleware($middleware){ | |
| return \Laravel\Lumen\Application::middleware($middleware); | |
| } | |
| /** | |
| * Define the route middleware for the application. | |
| * | |
| * @param array $middleware | |
| * @return $this | |
| * @static | |
| */ | |
| public static function routeMiddleware($middleware){ | |
| return \Laravel\Lumen\Application::routeMiddleware($middleware); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| * | |
| * @static | |
| */ | |
| public static function handle($request, $type = 1, $catch = true){ | |
| return \Laravel\Lumen\Application::handle($request, $type, $catch); | |
| } | |
| /** | |
| * Run the application and send the response. | |
| * | |
| * @param \Laravel\Lumen\SymfonyRequest|null $request | |
| * @return void | |
| * @static | |
| */ | |
| public static function run($request = null){ | |
| \Laravel\Lumen\Application::run($request); | |
| } | |
| /** | |
| * Dispatch the incoming request. | |
| * | |
| * @param \Laravel\Lumen\SymfonyRequest|null $request | |
| * @return \Laravel\Lumen\Response | |
| * @static | |
| */ | |
| public static function dispatch($request = null){ | |
| return \Laravel\Lumen\Application::dispatch($request); | |
| } | |
| /** | |
| * Set the FastRoute dispatcher instance. | |
| * | |
| * @param \FastRoute\Dispatcher $dispatcher | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDispatcher($dispatcher){ | |
| \Laravel\Lumen\Application::setDispatcher($dispatcher); | |
| } | |
| /** | |
| * Prepare the response for sending. | |
| * | |
| * @param mixed $response | |
| * @return \Laravel\Lumen\Response | |
| * @static | |
| */ | |
| public static function prepareResponse($response){ | |
| return \Laravel\Lumen\Application::prepareResponse($response); | |
| } | |
| /** | |
| * Get the current HTTP path info. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getPathInfo(){ | |
| return \Laravel\Lumen\Application::getPathInfo(); | |
| } | |
| /** | |
| * Get the base path for the application. | |
| * | |
| * @param string $path | |
| * @return string | |
| * @static | |
| */ | |
| public static function basePath($path = null){ | |
| return \Laravel\Lumen\Application::basePath($path); | |
| } | |
| /** | |
| * Get the storage path for the application. | |
| * | |
| * @param string $path | |
| * @return string | |
| * @static | |
| */ | |
| public static function storagePath($path = null){ | |
| return \Laravel\Lumen\Application::storagePath($path); | |
| } | |
| /** | |
| * Set a custom storage path for the application. | |
| * | |
| * @param string $path | |
| * @return $this | |
| * @static | |
| */ | |
| public static function useStoragePath($path){ | |
| return \Laravel\Lumen\Application::useStoragePath($path); | |
| } | |
| /** | |
| * Get the database path for the application. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function databasePath(){ | |
| return \Laravel\Lumen\Application::databasePath(); | |
| } | |
| /** | |
| * Set a custom configuration path for the application. | |
| * | |
| * @param string $path | |
| * @return $this | |
| * @static | |
| */ | |
| public static function useConfigPath($path){ | |
| return \Laravel\Lumen\Application::useConfigPath($path); | |
| } | |
| /** | |
| * Get the resource path for the application. | |
| * | |
| * @param string $path | |
| * @return string | |
| * @static | |
| */ | |
| public static function resourcePath($path = null){ | |
| return \Laravel\Lumen\Application::resourcePath($path); | |
| } | |
| /** | |
| * Set a custom resource path for the application. | |
| * | |
| * @param string $path | |
| * @return $this | |
| * @static | |
| */ | |
| public static function useResourcePath($path){ | |
| return \Laravel\Lumen\Application::useResourcePath($path); | |
| } | |
| /** | |
| * Determine if the application is running in the console. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function runningInConsole(){ | |
| return \Laravel\Lumen\Application::runningInConsole(); | |
| } | |
| /** | |
| * Prepare the application to execute a console command. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function prepareForConsoleCommand(){ | |
| \Laravel\Lumen\Application::prepareForConsoleCommand(); | |
| } | |
| /** | |
| * Get the raw routes for the application. | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getRoutes(){ | |
| return \Laravel\Lumen\Application::getRoutes(); | |
| } | |
| /** | |
| * Set the cached routes. | |
| * | |
| * @param array $routes | |
| * @return void | |
| * @static | |
| */ | |
| public static function setRoutes($routes){ | |
| \Laravel\Lumen\Application::setRoutes($routes); | |
| } | |
| /** | |
| * Get the HTML from the Lumen welcome screen. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function welcome(){ | |
| return \Laravel\Lumen\Application::welcome(); | |
| } | |
| /** | |
| * Define a contextual binding. | |
| * | |
| * @param string $concrete | |
| * @return \Illuminate\Contracts\Container\ContextualBindingBuilder | |
| * @static | |
| */ | |
| public static function when($concrete){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::when($concrete); | |
| } | |
| /** | |
| * Determine if the given abstract type has been bound. | |
| * | |
| * @param string $abstract | |
| * @return bool | |
| * @static | |
| */ | |
| public static function bound($abstract){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::bound($abstract); | |
| } | |
| /** | |
| * Determine if the given abstract type has been resolved. | |
| * | |
| * @param string $abstract | |
| * @return bool | |
| * @static | |
| */ | |
| public static function resolved($abstract){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::resolved($abstract); | |
| } | |
| /** | |
| * Determine if a given string is an alias. | |
| * | |
| * @param string $name | |
| * @return bool | |
| * @static | |
| */ | |
| public static function isAlias($name){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::isAlias($name); | |
| } | |
| /** | |
| * Register a binding with the container. | |
| * | |
| * @param string|array $abstract | |
| * @param \Closure|string|null $concrete | |
| * @param bool $shared | |
| * @return void | |
| * @static | |
| */ | |
| public static function bind($abstract, $concrete = null, $shared = false){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::bind($abstract, $concrete, $shared); | |
| } | |
| /** | |
| * Add a contextual binding to the container. | |
| * | |
| * @param string $concrete | |
| * @param string $abstract | |
| * @param \Closure|string $implementation | |
| * @static | |
| */ | |
| public static function addContextualBinding($concrete, $abstract, $implementation){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::addContextualBinding($concrete, $abstract, $implementation); | |
| } | |
| /** | |
| * Register a binding if it hasn't already been registered. | |
| * | |
| * @param string $abstract | |
| * @param \Closure|string|null $concrete | |
| * @param bool $shared | |
| * @return void | |
| * @static | |
| */ | |
| public static function bindIf($abstract, $concrete = null, $shared = false){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::bindIf($abstract, $concrete, $shared); | |
| } | |
| /** | |
| * Register a shared binding in the container. | |
| * | |
| * @param string $abstract | |
| * @param \Closure|string|null $concrete | |
| * @return void | |
| * @static | |
| */ | |
| public static function singleton($abstract, $concrete = null){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::singleton($abstract, $concrete); | |
| } | |
| /** | |
| * Wrap a Closure such that it is shared. | |
| * | |
| * @param \Closure $closure | |
| * @return \Closure | |
| * @static | |
| */ | |
| public static function share($closure){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::share($closure); | |
| } | |
| /** | |
| * Bind a shared Closure into the container. | |
| * | |
| * @param string $abstract | |
| * @param \Closure $closure | |
| * @return void | |
| * @deprecated since version 5.1. Use singleton instead. | |
| * @static | |
| */ | |
| public static function bindShared($abstract, $closure){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::bindShared($abstract, $closure); | |
| } | |
| /** | |
| * "Extend" an abstract type in the container. | |
| * | |
| * @param string $abstract | |
| * @param \Closure $closure | |
| * @return void | |
| * @throws \InvalidArgumentException | |
| * @static | |
| */ | |
| public static function extend($abstract, $closure){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::extend($abstract, $closure); | |
| } | |
| /** | |
| * Register an existing instance as shared in the container. | |
| * | |
| * @param string $abstract | |
| * @param mixed $instance | |
| * @return void | |
| * @static | |
| */ | |
| public static function instance($abstract, $instance){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::instance($abstract, $instance); | |
| } | |
| /** | |
| * Assign a set of tags to a given binding. | |
| * | |
| * @param array|string $abstracts | |
| * @param array|mixed $tags | |
| * @return void | |
| * @static | |
| */ | |
| public static function tag($abstracts, $tags){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::tag($abstracts, $tags); | |
| } | |
| /** | |
| * Resolve all of the bindings for a given tag. | |
| * | |
| * @param string $tag | |
| * @return array | |
| * @static | |
| */ | |
| public static function tagged($tag){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::tagged($tag); | |
| } | |
| /** | |
| * Alias a type to a different name. | |
| * | |
| * @param string $abstract | |
| * @param string $alias | |
| * @return void | |
| * @static | |
| */ | |
| public static function alias($abstract, $alias){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::alias($abstract, $alias); | |
| } | |
| /** | |
| * Bind a new callback to an abstract's rebind event. | |
| * | |
| * @param string $abstract | |
| * @param \Closure $callback | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function rebinding($abstract, $callback){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::rebinding($abstract, $callback); | |
| } | |
| /** | |
| * Refresh an instance on the given target and method. | |
| * | |
| * @param string $abstract | |
| * @param mixed $target | |
| * @param string $method | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function refresh($abstract, $target, $method){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::refresh($abstract, $target, $method); | |
| } | |
| /** | |
| * Wrap the given closure such that its dependencies will be injected when executed. | |
| * | |
| * @param \Closure $callback | |
| * @param array $parameters | |
| * @return \Closure | |
| * @static | |
| */ | |
| public static function wrap($callback, $parameters = array()){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::wrap($callback, $parameters); | |
| } | |
| /** | |
| * Call the given Closure / class@method and inject its dependencies. | |
| * | |
| * @param callable|string $callback | |
| * @param array $parameters | |
| * @param string|null $defaultMethod | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function call($callback, $parameters = array(), $defaultMethod = null){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::call($callback, $parameters, $defaultMethod); | |
| } | |
| /** | |
| * Instantiate a concrete instance of the given type. | |
| * | |
| * @param string $concrete | |
| * @param array $parameters | |
| * @return mixed | |
| * @throws \Illuminate\Contracts\Container\BindingResolutionException | |
| * @static | |
| */ | |
| public static function build($concrete, $parameters = array()){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::build($concrete, $parameters); | |
| } | |
| /** | |
| * Register a new resolving callback. | |
| * | |
| * @param string $abstract | |
| * @param \Closure|null $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function resolving($abstract, $callback = null){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::resolving($abstract, $callback); | |
| } | |
| /** | |
| * Register a new after resolving callback for all types. | |
| * | |
| * @param string $abstract | |
| * @param \Closure|null $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function afterResolving($abstract, $callback = null){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::afterResolving($abstract, $callback); | |
| } | |
| /** | |
| * Determine if a given type is shared. | |
| * | |
| * @param string $abstract | |
| * @return bool | |
| * @static | |
| */ | |
| public static function isShared($abstract){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::isShared($abstract); | |
| } | |
| /** | |
| * Get the container's bindings. | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getBindings(){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::getBindings(); | |
| } | |
| /** | |
| * Remove a resolved instance from the instance cache. | |
| * | |
| * @param string $abstract | |
| * @return void | |
| * @static | |
| */ | |
| public static function forgetInstance($abstract){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::forgetInstance($abstract); | |
| } | |
| /** | |
| * Clear all of the instances from the container. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function forgetInstances(){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::forgetInstances(); | |
| } | |
| /** | |
| * Flush the container of all bindings and resolved instances. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function flush(){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::flush(); | |
| } | |
| /** | |
| * Set the globally available instance of the container. | |
| * | |
| * @return static | |
| * @static | |
| */ | |
| public static function getInstance(){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::getInstance(); | |
| } | |
| /** | |
| * Set the shared instance of the container. | |
| * | |
| * @param \Illuminate\Contracts\Container\Container $container | |
| * @return void | |
| * @static | |
| */ | |
| public static function setInstance($container){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::setInstance($container); | |
| } | |
| /** | |
| * Determine if a given offset exists. | |
| * | |
| * @param string $key | |
| * @return bool | |
| * @static | |
| */ | |
| public static function offsetExists($key){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::offsetExists($key); | |
| } | |
| /** | |
| * Get the value at a given offset. | |
| * | |
| * @param string $key | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function offsetGet($key){ | |
| //Method inherited from \Illuminate\Container\Container | |
| return \Laravel\Lumen\Application::offsetGet($key); | |
| } | |
| /** | |
| * Set the value at a given offset. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @return void | |
| * @static | |
| */ | |
| public static function offsetSet($key, $value){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::offsetSet($key, $value); | |
| } | |
| /** | |
| * Unset the value at a given offset. | |
| * | |
| * @param string $key | |
| * @return void | |
| * @static | |
| */ | |
| public static function offsetUnset($key){ | |
| //Method inherited from \Illuminate\Container\Container | |
| \Laravel\Lumen\Application::offsetUnset($key); | |
| } | |
| } | |
| class Auth extends \Illuminate\Support\Facades\Auth{ | |
| /** | |
| * Create an instance of the database driver. | |
| * | |
| * @return \Illuminate\Auth\Guard | |
| * @static | |
| */ | |
| public static function createDatabaseDriver(){ | |
| return \Illuminate\Auth\AuthManager::createDatabaseDriver(); | |
| } | |
| /** | |
| * Create an instance of the Eloquent driver. | |
| * | |
| * @return \Illuminate\Auth\Guard | |
| * @static | |
| */ | |
| public static function createEloquentDriver(){ | |
| return \Illuminate\Auth\AuthManager::createEloquentDriver(); | |
| } | |
| /** | |
| * Get the default authentication driver name. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDefaultDriver(){ | |
| return \Illuminate\Auth\AuthManager::getDefaultDriver(); | |
| } | |
| /** | |
| * Set the default authentication driver name. | |
| * | |
| * @param string $name | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDefaultDriver($name){ | |
| \Illuminate\Auth\AuthManager::setDefaultDriver($name); | |
| } | |
| /** | |
| * Get a driver instance. | |
| * | |
| * @param string $driver | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function driver($driver = null){ | |
| //Method inherited from \Illuminate\Support\Manager | |
| return \Illuminate\Auth\AuthManager::driver($driver); | |
| } | |
| /** | |
| * Register a custom driver creator Closure. | |
| * | |
| * @param string $driver | |
| * @param \Closure $callback | |
| * @return $this | |
| * @static | |
| */ | |
| public static function extend($driver, $callback){ | |
| //Method inherited from \Illuminate\Support\Manager | |
| return \Illuminate\Auth\AuthManager::extend($driver, $callback); | |
| } | |
| /** | |
| * Get all of the created "drivers". | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getDrivers(){ | |
| //Method inherited from \Illuminate\Support\Manager | |
| return \Illuminate\Auth\AuthManager::getDrivers(); | |
| } | |
| /** | |
| * Determine if the current user is authenticated. | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function check(){ | |
| return \Illuminate\Auth\Guard::check(); | |
| } | |
| /** | |
| * Determine if the current user is a guest. | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function guest(){ | |
| return \Illuminate\Auth\Guard::guest(); | |
| } | |
| /** | |
| * Get the currently authenticated user. | |
| * | |
| * @return \App\User|null | |
| * @static | |
| */ | |
| public static function user(){ | |
| return \Illuminate\Auth\Guard::user(); | |
| } | |
| /** | |
| * Get the ID for the currently authenticated user. | |
| * | |
| * @return int|null | |
| * @static | |
| */ | |
| public static function id(){ | |
| return \Illuminate\Auth\Guard::id(); | |
| } | |
| /** | |
| * Log a user into the application without sessions or cookies. | |
| * | |
| * @param array $credentials | |
| * @return bool | |
| * @static | |
| */ | |
| public static function once($credentials = array()){ | |
| return \Illuminate\Auth\Guard::once($credentials); | |
| } | |
| /** | |
| * Validate a user's credentials. | |
| * | |
| * @param array $credentials | |
| * @return bool | |
| * @static | |
| */ | |
| public static function validate($credentials = array()){ | |
| return \Illuminate\Auth\Guard::validate($credentials); | |
| } | |
| /** | |
| * Attempt to authenticate using HTTP Basic Auth. | |
| * | |
| * @param string $field | |
| * @return \Symfony\Component\HttpFoundation\Response|null | |
| * @static | |
| */ | |
| public static function basic($field = 'email'){ | |
| return \Illuminate\Auth\Guard::basic($field); | |
| } | |
| /** | |
| * Perform a stateless HTTP Basic login attempt. | |
| * | |
| * @param string $field | |
| * @return \Symfony\Component\HttpFoundation\Response|null | |
| * @static | |
| */ | |
| public static function onceBasic($field = 'email'){ | |
| return \Illuminate\Auth\Guard::onceBasic($field); | |
| } | |
| /** | |
| * Attempt to authenticate a user using the given credentials. | |
| * | |
| * @param array $credentials | |
| * @param bool $remember | |
| * @param bool $login | |
| * @return bool | |
| * @static | |
| */ | |
| public static function attempt($credentials = array(), $remember = false, $login = true){ | |
| return \Illuminate\Auth\Guard::attempt($credentials, $remember, $login); | |
| } | |
| /** | |
| * Register an authentication attempt event listener. | |
| * | |
| * @param mixed $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function attempting($callback){ | |
| \Illuminate\Auth\Guard::attempting($callback); | |
| } | |
| /** | |
| * Log a user into the application. | |
| * | |
| * @param \Illuminate\Contracts\Auth\Authenticatable $user | |
| * @param bool $remember | |
| * @return void | |
| * @static | |
| */ | |
| public static function login($user, $remember = false){ | |
| \Illuminate\Auth\Guard::login($user, $remember); | |
| } | |
| /** | |
| * Log the given user ID into the application. | |
| * | |
| * @param mixed $id | |
| * @param bool $remember | |
| * @return \App\User | |
| * @static | |
| */ | |
| public static function loginUsingId($id, $remember = false){ | |
| return \Illuminate\Auth\Guard::loginUsingId($id, $remember); | |
| } | |
| /** | |
| * Log the given user ID into the application without sessions or cookies. | |
| * | |
| * @param mixed $id | |
| * @return bool | |
| * @static | |
| */ | |
| public static function onceUsingId($id){ | |
| return \Illuminate\Auth\Guard::onceUsingId($id); | |
| } | |
| /** | |
| * Log the user out of the application. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function logout(){ | |
| \Illuminate\Auth\Guard::logout(); | |
| } | |
| /** | |
| * Get the cookie creator instance used by the guard. | |
| * | |
| * @return \Illuminate\Contracts\Cookie\QueueingFactory | |
| * @throws \RuntimeException | |
| * @static | |
| */ | |
| public static function getCookieJar(){ | |
| return \Illuminate\Auth\Guard::getCookieJar(); | |
| } | |
| /** | |
| * Set the cookie creator instance used by the guard. | |
| * | |
| * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie | |
| * @return void | |
| * @static | |
| */ | |
| public static function setCookieJar($cookie){ | |
| \Illuminate\Auth\Guard::setCookieJar($cookie); | |
| } | |
| /** | |
| * Get the event dispatcher instance. | |
| * | |
| * @return \Illuminate\Contracts\Events\Dispatcher | |
| * @static | |
| */ | |
| public static function getDispatcher(){ | |
| return \Illuminate\Auth\Guard::getDispatcher(); | |
| } | |
| /** | |
| * Set the event dispatcher instance. | |
| * | |
| * @param \Illuminate\Contracts\Events\Dispatcher $events | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDispatcher($events){ | |
| \Illuminate\Auth\Guard::setDispatcher($events); | |
| } | |
| /** | |
| * Get the session store used by the guard. | |
| * | |
| * @return \Illuminate\Session\Store | |
| * @static | |
| */ | |
| public static function getSession(){ | |
| return \Illuminate\Auth\Guard::getSession(); | |
| } | |
| /** | |
| * Get the user provider used by the guard. | |
| * | |
| * @return \Illuminate\Contracts\Auth\UserProvider | |
| * @static | |
| */ | |
| public static function getProvider(){ | |
| return \Illuminate\Auth\Guard::getProvider(); | |
| } | |
| /** | |
| * Set the user provider used by the guard. | |
| * | |
| * @param \Illuminate\Contracts\Auth\UserProvider $provider | |
| * @return void | |
| * @static | |
| */ | |
| public static function setProvider($provider){ | |
| \Illuminate\Auth\Guard::setProvider($provider); | |
| } | |
| /** | |
| * Return the currently cached user. | |
| * | |
| * @return \App\User|null | |
| * @static | |
| */ | |
| public static function getUser(){ | |
| return \Illuminate\Auth\Guard::getUser(); | |
| } | |
| /** | |
| * Set the current user. | |
| * | |
| * @param \Illuminate\Contracts\Auth\Authenticatable $user | |
| * @return void | |
| * @static | |
| */ | |
| public static function setUser($user){ | |
| \Illuminate\Auth\Guard::setUser($user); | |
| } | |
| /** | |
| * Get the current request instance. | |
| * | |
| * @return \Symfony\Component\HttpFoundation\Request | |
| * @static | |
| */ | |
| public static function getRequest(){ | |
| return \Illuminate\Auth\Guard::getRequest(); | |
| } | |
| /** | |
| * Set the current request instance. | |
| * | |
| * @param \Symfony\Component\HttpFoundation\Request $request | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setRequest($request){ | |
| return \Illuminate\Auth\Guard::setRequest($request); | |
| } | |
| /** | |
| * Get the last user we attempted to authenticate. | |
| * | |
| * @return \App\User | |
| * @static | |
| */ | |
| public static function getLastAttempted(){ | |
| return \Illuminate\Auth\Guard::getLastAttempted(); | |
| } | |
| /** | |
| * Get a unique identifier for the auth session value. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getName(){ | |
| return \Illuminate\Auth\Guard::getName(); | |
| } | |
| /** | |
| * Get the name of the cookie used to store the "recaller". | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getRecallerName(){ | |
| return \Illuminate\Auth\Guard::getRecallerName(); | |
| } | |
| /** | |
| * Determine if the user was authenticated via "remember me" cookie. | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function viaRemember(){ | |
| return \Illuminate\Auth\Guard::viaRemember(); | |
| } | |
| } | |
| class Bus extends \Illuminate\Support\Facades\Bus{ | |
| /** | |
| * Marshal a command and dispatch it to its appropriate handler. | |
| * | |
| * @param mixed $command | |
| * @param array $array | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function dispatchFromArray($command, $array){ | |
| return \Illuminate\Bus\Dispatcher::dispatchFromArray($command, $array); | |
| } | |
| /** | |
| * Marshal a command and dispatch it to its appropriate handler. | |
| * | |
| * @param mixed $command | |
| * @param \ArrayAccess $source | |
| * @param array $extras | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function dispatchFrom($command, $source, $extras = array()){ | |
| return \Illuminate\Bus\Dispatcher::dispatchFrom($command, $source, $extras); | |
| } | |
| /** | |
| * Dispatch a command to its appropriate handler. | |
| * | |
| * @param mixed $command | |
| * @param \Closure|null $afterResolving | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function dispatch($command, $afterResolving = null){ | |
| return \Illuminate\Bus\Dispatcher::dispatch($command, $afterResolving); | |
| } | |
| /** | |
| * Dispatch a command to its appropriate handler in the current process. | |
| * | |
| * @param mixed $command | |
| * @param \Closure|null $afterResolving | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function dispatchNow($command, $afterResolving = null){ | |
| return \Illuminate\Bus\Dispatcher::dispatchNow($command, $afterResolving); | |
| } | |
| /** | |
| * Dispatch a command to its appropriate handler behind a queue. | |
| * | |
| * @param mixed $command | |
| * @return mixed | |
| * @throws \RuntimeException | |
| * @static | |
| */ | |
| public static function dispatchToQueue($command){ | |
| return \Illuminate\Bus\Dispatcher::dispatchToQueue($command); | |
| } | |
| /** | |
| * Get the handler instance for the given command. | |
| * | |
| * @param mixed $command | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function resolveHandler($command){ | |
| return \Illuminate\Bus\Dispatcher::resolveHandler($command); | |
| } | |
| /** | |
| * Get the handler class for the given command. | |
| * | |
| * @param mixed $command | |
| * @return string | |
| * @static | |
| */ | |
| public static function getHandlerClass($command){ | |
| return \Illuminate\Bus\Dispatcher::getHandlerClass($command); | |
| } | |
| /** | |
| * Get the handler method for the given command. | |
| * | |
| * @param mixed $command | |
| * @return string | |
| * @static | |
| */ | |
| public static function getHandlerMethod($command){ | |
| return \Illuminate\Bus\Dispatcher::getHandlerMethod($command); | |
| } | |
| /** | |
| * Register command-to-handler mappings. | |
| * | |
| * @param array $commands | |
| * @return void | |
| * @static | |
| */ | |
| public static function maps($commands){ | |
| \Illuminate\Bus\Dispatcher::maps($commands); | |
| } | |
| /** | |
| * Register a fallback mapper callback. | |
| * | |
| * @param \Closure $mapper | |
| * @return void | |
| * @static | |
| */ | |
| public static function mapUsing($mapper){ | |
| \Illuminate\Bus\Dispatcher::mapUsing($mapper); | |
| } | |
| /** | |
| * Map the command to a handler within a given root namespace. | |
| * | |
| * @param mixed $command | |
| * @param string $commandNamespace | |
| * @param string $handlerNamespace | |
| * @return string | |
| * @static | |
| */ | |
| public static function simpleMapping($command, $commandNamespace, $handlerNamespace){ | |
| return \Illuminate\Bus\Dispatcher::simpleMapping($command, $commandNamespace, $handlerNamespace); | |
| } | |
| /** | |
| * Set the pipes through which commands should be piped before dispatching. | |
| * | |
| * @param array $pipes | |
| * @return $this | |
| * @static | |
| */ | |
| public static function pipeThrough($pipes){ | |
| return \Illuminate\Bus\Dispatcher::pipeThrough($pipes); | |
| } | |
| } | |
| class DB extends \Illuminate\Support\Facades\DB{ | |
| /** | |
| * Get a database connection instance. | |
| * | |
| * @param string $name | |
| * @return \Illuminate\Database\Connection | |
| * @static | |
| */ | |
| public static function connection($name = null){ | |
| return \Illuminate\Database\DatabaseManager::connection($name); | |
| } | |
| /** | |
| * Disconnect from the given database and remove from local cache. | |
| * | |
| * @param string $name | |
| * @return void | |
| * @static | |
| */ | |
| public static function purge($name = null){ | |
| \Illuminate\Database\DatabaseManager::purge($name); | |
| } | |
| /** | |
| * Disconnect from the given database. | |
| * | |
| * @param string $name | |
| * @return void | |
| * @static | |
| */ | |
| public static function disconnect($name = null){ | |
| \Illuminate\Database\DatabaseManager::disconnect($name); | |
| } | |
| /** | |
| * Reconnect to the given database. | |
| * | |
| * @param string $name | |
| * @return \Illuminate\Database\Connection | |
| * @static | |
| */ | |
| public static function reconnect($name = null){ | |
| return \Illuminate\Database\DatabaseManager::reconnect($name); | |
| } | |
| /** | |
| * Get the default connection name. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDefaultConnection(){ | |
| return \Illuminate\Database\DatabaseManager::getDefaultConnection(); | |
| } | |
| /** | |
| * Set the default connection name. | |
| * | |
| * @param string $name | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDefaultConnection($name){ | |
| \Illuminate\Database\DatabaseManager::setDefaultConnection($name); | |
| } | |
| /** | |
| * Register an extension connection resolver. | |
| * | |
| * @param string $name | |
| * @param callable $resolver | |
| * @return void | |
| * @static | |
| */ | |
| public static function extend($name, $resolver){ | |
| \Illuminate\Database\DatabaseManager::extend($name, $resolver); | |
| } | |
| /** | |
| * Return all of the created connections. | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getConnections(){ | |
| return \Illuminate\Database\DatabaseManager::getConnections(); | |
| } | |
| /** | |
| * Get a schema builder instance for the connection. | |
| * | |
| * @return \Illuminate\Database\Schema\MySqlBuilder | |
| * @static | |
| */ | |
| public static function getSchemaBuilder(){ | |
| return \Illuminate\Database\MySqlConnection::getSchemaBuilder(); | |
| } | |
| /** | |
| * Set the query grammar to the default implementation. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function useDefaultQueryGrammar(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::useDefaultQueryGrammar(); | |
| } | |
| /** | |
| * Set the schema grammar to the default implementation. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function useDefaultSchemaGrammar(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::useDefaultSchemaGrammar(); | |
| } | |
| /** | |
| * Set the query post processor to the default implementation. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function useDefaultPostProcessor(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::useDefaultPostProcessor(); | |
| } | |
| /** | |
| * Begin a fluent query against a database table. | |
| * | |
| * @param string $table | |
| * @return \Illuminate\Database\Query\Builder | |
| * @static | |
| */ | |
| public static function table($table){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::table($table); | |
| } | |
| /** | |
| * Get a new raw query expression. | |
| * | |
| * @param mixed $value | |
| * @return \Illuminate\Database\Query\Expression | |
| * @static | |
| */ | |
| public static function raw($value){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::raw($value); | |
| } | |
| /** | |
| * Run a select statement and return a single result. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function selectOne($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::selectOne($query, $bindings); | |
| } | |
| /** | |
| * Run a select statement against the database. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return array | |
| * @static | |
| */ | |
| public static function selectFromWriteConnection($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::selectFromWriteConnection($query, $bindings); | |
| } | |
| /** | |
| * Run a select statement against the database. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @param bool $useReadPdo | |
| * @return array | |
| * @static | |
| */ | |
| public static function select($query, $bindings = array(), $useReadPdo = true){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::select($query, $bindings, $useReadPdo); | |
| } | |
| /** | |
| * Run an insert statement against the database. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return bool | |
| * @static | |
| */ | |
| public static function insert($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::insert($query, $bindings); | |
| } | |
| /** | |
| * Run an update statement against the database. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return int | |
| * @static | |
| */ | |
| public static function update($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::update($query, $bindings); | |
| } | |
| /** | |
| * Run a delete statement against the database. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return int | |
| * @static | |
| */ | |
| public static function delete($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::delete($query, $bindings); | |
| } | |
| /** | |
| * Execute an SQL statement and return the boolean result. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return bool | |
| * @static | |
| */ | |
| public static function statement($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::statement($query, $bindings); | |
| } | |
| /** | |
| * Run an SQL statement and get the number of rows affected. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @return int | |
| * @static | |
| */ | |
| public static function affectingStatement($query, $bindings = array()){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::affectingStatement($query, $bindings); | |
| } | |
| /** | |
| * Run a raw, unprepared query against the PDO connection. | |
| * | |
| * @param string $query | |
| * @return bool | |
| * @static | |
| */ | |
| public static function unprepared($query){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::unprepared($query); | |
| } | |
| /** | |
| * Prepare the query bindings for execution. | |
| * | |
| * @param array $bindings | |
| * @return array | |
| * @static | |
| */ | |
| public static function prepareBindings($bindings){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::prepareBindings($bindings); | |
| } | |
| /** | |
| * Execute a Closure within a transaction. | |
| * | |
| * @param \Closure $callback | |
| * @return mixed | |
| * @throws \Throwable | |
| * @static | |
| */ | |
| public static function transaction($callback){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::transaction($callback); | |
| } | |
| /** | |
| * Start a new database transaction. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function beginTransaction(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::beginTransaction(); | |
| } | |
| /** | |
| * Commit the active database transaction. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function commit(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::commit(); | |
| } | |
| /** | |
| * Rollback the active database transaction. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function rollBack(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::rollBack(); | |
| } | |
| /** | |
| * Get the number of active transactions. | |
| * | |
| * @return int | |
| * @static | |
| */ | |
| public static function transactionLevel(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::transactionLevel(); | |
| } | |
| /** | |
| * Execute the given callback in "dry run" mode. | |
| * | |
| * @param \Closure $callback | |
| * @return array | |
| * @static | |
| */ | |
| public static function pretend($callback){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::pretend($callback); | |
| } | |
| /** | |
| * Log a query in the connection's query log. | |
| * | |
| * @param string $query | |
| * @param array $bindings | |
| * @param float|null $time | |
| * @return void | |
| * @static | |
| */ | |
| public static function logQuery($query, $bindings, $time = null){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::logQuery($query, $bindings, $time); | |
| } | |
| /** | |
| * Register a database query listener with the connection. | |
| * | |
| * @param \Closure $callback | |
| * @return void | |
| * @static | |
| */ | |
| public static function listen($callback){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::listen($callback); | |
| } | |
| /** | |
| * Get a Doctrine Schema Column instance. | |
| * | |
| * @param string $table | |
| * @param string $column | |
| * @return \Doctrine\DBAL\Schema\Column | |
| * @static | |
| */ | |
| public static function getDoctrineColumn($table, $column){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getDoctrineColumn($table, $column); | |
| } | |
| /** | |
| * Get the Doctrine DBAL schema manager for the connection. | |
| * | |
| * @return \Doctrine\DBAL\Schema\AbstractSchemaManager | |
| * @static | |
| */ | |
| public static function getDoctrineSchemaManager(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getDoctrineSchemaManager(); | |
| } | |
| /** | |
| * Get the Doctrine DBAL database connection instance. | |
| * | |
| * @return \Doctrine\DBAL\Connection | |
| * @static | |
| */ | |
| public static function getDoctrineConnection(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getDoctrineConnection(); | |
| } | |
| /** | |
| * Get the current PDO connection. | |
| * | |
| * @return \PDO | |
| * @static | |
| */ | |
| public static function getPdo(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getPdo(); | |
| } | |
| /** | |
| * Get the current PDO connection used for reading. | |
| * | |
| * @return \PDO | |
| * @static | |
| */ | |
| public static function getReadPdo(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getReadPdo(); | |
| } | |
| /** | |
| * Set the PDO connection. | |
| * | |
| * @param \PDO|null $pdo | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setPdo($pdo){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::setPdo($pdo); | |
| } | |
| /** | |
| * Set the PDO connection used for reading. | |
| * | |
| * @param \PDO|null $pdo | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setReadPdo($pdo){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::setReadPdo($pdo); | |
| } | |
| /** | |
| * Set the reconnect instance on the connection. | |
| * | |
| * @param callable $reconnector | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setReconnector($reconnector){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::setReconnector($reconnector); | |
| } | |
| /** | |
| * Get the database connection name. | |
| * | |
| * @return string|null | |
| * @static | |
| */ | |
| public static function getName(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getName(); | |
| } | |
| /** | |
| * Get an option from the configuration options. | |
| * | |
| * @param string $option | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function getConfig($option){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getConfig($option); | |
| } | |
| /** | |
| * Get the PDO driver name. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDriverName(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getDriverName(); | |
| } | |
| /** | |
| * Get the query grammar used by the connection. | |
| * | |
| * @return \Illuminate\Database\Query\Grammars\Grammar | |
| * @static | |
| */ | |
| public static function getQueryGrammar(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getQueryGrammar(); | |
| } | |
| /** | |
| * Set the query grammar used by the connection. | |
| * | |
| * @param \Illuminate\Database\Query\Grammars\Grammar $grammar | |
| * @return void | |
| * @static | |
| */ | |
| public static function setQueryGrammar($grammar){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::setQueryGrammar($grammar); | |
| } | |
| /** | |
| * Get the schema grammar used by the connection. | |
| * | |
| * @return \Illuminate\Database\Schema\Grammars\Grammar | |
| * @static | |
| */ | |
| public static function getSchemaGrammar(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getSchemaGrammar(); | |
| } | |
| /** | |
| * Set the schema grammar used by the connection. | |
| * | |
| * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar | |
| * @return void | |
| * @static | |
| */ | |
| public static function setSchemaGrammar($grammar){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::setSchemaGrammar($grammar); | |
| } | |
| /** | |
| * Get the query post processor used by the connection. | |
| * | |
| * @return \Illuminate\Database\Query\Processors\Processor | |
| * @static | |
| */ | |
| public static function getPostProcessor(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getPostProcessor(); | |
| } | |
| /** | |
| * Set the query post processor used by the connection. | |
| * | |
| * @param \Illuminate\Database\Query\Processors\Processor $processor | |
| * @return void | |
| * @static | |
| */ | |
| public static function setPostProcessor($processor){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::setPostProcessor($processor); | |
| } | |
| /** | |
| * Get the event dispatcher used by the connection. | |
| * | |
| * @return \Illuminate\Contracts\Events\Dispatcher | |
| * @static | |
| */ | |
| public static function getEventDispatcher(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getEventDispatcher(); | |
| } | |
| /** | |
| * Set the event dispatcher instance on the connection. | |
| * | |
| * @param \Illuminate\Contracts\Events\Dispatcher $events | |
| * @return void | |
| * @static | |
| */ | |
| public static function setEventDispatcher($events){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::setEventDispatcher($events); | |
| } | |
| /** | |
| * Determine if the connection in a "dry run". | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function pretending(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::pretending(); | |
| } | |
| /** | |
| * Get the default fetch mode for the connection. | |
| * | |
| * @return int | |
| * @static | |
| */ | |
| public static function getFetchMode(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getFetchMode(); | |
| } | |
| /** | |
| * Set the default fetch mode for the connection. | |
| * | |
| * @param int $fetchMode | |
| * @return int | |
| * @static | |
| */ | |
| public static function setFetchMode($fetchMode){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::setFetchMode($fetchMode); | |
| } | |
| /** | |
| * Get the connection query log. | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getQueryLog(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getQueryLog(); | |
| } | |
| /** | |
| * Clear the query log. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function flushQueryLog(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::flushQueryLog(); | |
| } | |
| /** | |
| * Enable the query log on the connection. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function enableQueryLog(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::enableQueryLog(); | |
| } | |
| /** | |
| * Disable the query log on the connection. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function disableQueryLog(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::disableQueryLog(); | |
| } | |
| /** | |
| * Determine whether we're logging queries. | |
| * | |
| * @return bool | |
| * @static | |
| */ | |
| public static function logging(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::logging(); | |
| } | |
| /** | |
| * Get the name of the connected database. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDatabaseName(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getDatabaseName(); | |
| } | |
| /** | |
| * Set the name of the connected database. | |
| * | |
| * @param string $database | |
| * @return string | |
| * @static | |
| */ | |
| public static function setDatabaseName($database){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::setDatabaseName($database); | |
| } | |
| /** | |
| * Get the table prefix for the connection. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getTablePrefix(){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::getTablePrefix(); | |
| } | |
| /** | |
| * Set the table prefix in use by the connection. | |
| * | |
| * @param string $prefix | |
| * @return void | |
| * @static | |
| */ | |
| public static function setTablePrefix($prefix){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| \Illuminate\Database\MySqlConnection::setTablePrefix($prefix); | |
| } | |
| /** | |
| * Set the table prefix and return the grammar. | |
| * | |
| * @param \Illuminate\Database\Grammar $grammar | |
| * @return \Illuminate\Database\Grammar | |
| * @static | |
| */ | |
| public static function withTablePrefix($grammar){ | |
| //Method inherited from \Illuminate\Database\Connection | |
| return \Illuminate\Database\MySqlConnection::withTablePrefix($grammar); | |
| } | |
| } | |
| class Cache extends \Illuminate\Support\Facades\Cache{ | |
| /** | |
| * Get a cache store instance by name. | |
| * | |
| * @param string|null $name | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function store($name = null){ | |
| return \Illuminate\Cache\CacheManager::store($name); | |
| } | |
| /** | |
| * Get a cache driver instance. | |
| * | |
| * @param string $driver | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function driver($driver = null){ | |
| return \Illuminate\Cache\CacheManager::driver($driver); | |
| } | |
| /** | |
| * Create a new cache repository with the given implementation. | |
| * | |
| * @param \Illuminate\Contracts\Cache\Store $store | |
| * @return \Illuminate\Cache\Repository | |
| * @static | |
| */ | |
| public static function repository($store){ | |
| return \Illuminate\Cache\CacheManager::repository($store); | |
| } | |
| /** | |
| * Get the default cache driver name. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDefaultDriver(){ | |
| return \Illuminate\Cache\CacheManager::getDefaultDriver(); | |
| } | |
| /** | |
| * Set the default cache driver name. | |
| * | |
| * @param string $name | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDefaultDriver($name){ | |
| \Illuminate\Cache\CacheManager::setDefaultDriver($name); | |
| } | |
| /** | |
| * Register a custom driver creator Closure. | |
| * | |
| * @param string $driver | |
| * @param \Closure $callback | |
| * @return $this | |
| * @static | |
| */ | |
| public static function extend($driver, $callback){ | |
| return \Illuminate\Cache\CacheManager::extend($driver, $callback); | |
| } | |
| /** | |
| * Set the event dispatcher instance. | |
| * | |
| * @param \Illuminate\Contracts\Events\Dispatcher $events | |
| * @return void | |
| * @static | |
| */ | |
| public static function setEventDispatcher($events){ | |
| \Illuminate\Cache\Repository::setEventDispatcher($events); | |
| } | |
| /** | |
| * Determine if an item exists in the cache. | |
| * | |
| * @param string $key | |
| * @return bool | |
| * @static | |
| */ | |
| public static function has($key){ | |
| return \Illuminate\Cache\Repository::has($key); | |
| } | |
| /** | |
| * Retrieve an item from the cache by key. | |
| * | |
| * @param string $key | |
| * @param mixed $default | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function get($key, $default = null){ | |
| return \Illuminate\Cache\Repository::get($key, $default); | |
| } | |
| /** | |
| * Retrieve an item from the cache and delete it. | |
| * | |
| * @param string $key | |
| * @param mixed $default | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function pull($key, $default = null){ | |
| return \Illuminate\Cache\Repository::pull($key, $default); | |
| } | |
| /** | |
| * Store an item in the cache. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @param \DateTime|int $minutes | |
| * @return void | |
| * @static | |
| */ | |
| public static function put($key, $value, $minutes){ | |
| \Illuminate\Cache\Repository::put($key, $value, $minutes); | |
| } | |
| /** | |
| * Store an item in the cache if the key does not exist. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @param \DateTime|int $minutes | |
| * @return bool | |
| * @static | |
| */ | |
| public static function add($key, $value, $minutes){ | |
| return \Illuminate\Cache\Repository::add($key, $value, $minutes); | |
| } | |
| /** | |
| * Store an item in the cache indefinitely. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @return void | |
| * @static | |
| */ | |
| public static function forever($key, $value){ | |
| \Illuminate\Cache\Repository::forever($key, $value); | |
| } | |
| /** | |
| * Get an item from the cache, or store the default value. | |
| * | |
| * @param string $key | |
| * @param \DateTime|int $minutes | |
| * @param \Closure $callback | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function remember($key, $minutes, $callback){ | |
| return \Illuminate\Cache\Repository::remember($key, $minutes, $callback); | |
| } | |
| /** | |
| * Get an item from the cache, or store the default value forever. | |
| * | |
| * @param string $key | |
| * @param \Closure $callback | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function sear($key, $callback){ | |
| return \Illuminate\Cache\Repository::sear($key, $callback); | |
| } | |
| /** | |
| * Get an item from the cache, or store the default value forever. | |
| * | |
| * @param string $key | |
| * @param \Closure $callback | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function rememberForever($key, $callback){ | |
| return \Illuminate\Cache\Repository::rememberForever($key, $callback); | |
| } | |
| /** | |
| * Remove an item from the cache. | |
| * | |
| * @param string $key | |
| * @return bool | |
| * @static | |
| */ | |
| public static function forget($key){ | |
| return \Illuminate\Cache\Repository::forget($key); | |
| } | |
| /** | |
| * Get the default cache time. | |
| * | |
| * @return int | |
| * @static | |
| */ | |
| public static function getDefaultCacheTime(){ | |
| return \Illuminate\Cache\Repository::getDefaultCacheTime(); | |
| } | |
| /** | |
| * Set the default cache time in minutes. | |
| * | |
| * @param int $minutes | |
| * @return void | |
| * @static | |
| */ | |
| public static function setDefaultCacheTime($minutes){ | |
| \Illuminate\Cache\Repository::setDefaultCacheTime($minutes); | |
| } | |
| /** | |
| * Get the cache store implementation. | |
| * | |
| * @return \Illuminate\Contracts\Cache\Store | |
| * @static | |
| */ | |
| public static function getStore(){ | |
| return \Illuminate\Cache\Repository::getStore(); | |
| } | |
| /** | |
| * Determine if a cached value exists. | |
| * | |
| * @param string $key | |
| * @return bool | |
| * @static | |
| */ | |
| public static function offsetExists($key){ | |
| return \Illuminate\Cache\Repository::offsetExists($key); | |
| } | |
| /** | |
| * Retrieve an item from the cache by key. | |
| * | |
| * @param string $key | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function offsetGet($key){ | |
| return \Illuminate\Cache\Repository::offsetGet($key); | |
| } | |
| /** | |
| * Store an item in the cache for the default time. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @return void | |
| * @static | |
| */ | |
| public static function offsetSet($key, $value){ | |
| \Illuminate\Cache\Repository::offsetSet($key, $value); | |
| } | |
| /** | |
| * Remove an item from the cache. | |
| * | |
| * @param string $key | |
| * @return void | |
| * @static | |
| */ | |
| public static function offsetUnset($key){ | |
| \Illuminate\Cache\Repository::offsetUnset($key); | |
| } | |
| /** | |
| * Register a custom macro. | |
| * | |
| * @param string $name | |
| * @param callable $macro | |
| * @return void | |
| * @static | |
| */ | |
| public static function macro($name, $macro){ | |
| \Illuminate\Cache\Repository::macro($name, $macro); | |
| } | |
| /** | |
| * Checks if macro is registered. | |
| * | |
| * @param string $name | |
| * @return bool | |
| * @static | |
| */ | |
| public static function hasMacro($name){ | |
| return \Illuminate\Cache\Repository::hasMacro($name); | |
| } | |
| /** | |
| * Dynamically handle calls to the class. | |
| * | |
| * @param string $method | |
| * @param array $parameters | |
| * @return mixed | |
| * @throws \BadMethodCallException | |
| * @static | |
| */ | |
| public static function macroCall($method, $parameters){ | |
| return \Illuminate\Cache\Repository::macroCall($method, $parameters); | |
| } | |
| /** | |
| * Increment the value of an item in the cache. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @return int | |
| * @static | |
| */ | |
| public static function increment($key, $value = 1){ | |
| return \Illuminate\Cache\FileStore::increment($key, $value); | |
| } | |
| /** | |
| * Decrement the value of an item in the cache. | |
| * | |
| * @param string $key | |
| * @param mixed $value | |
| * @return int | |
| * @static | |
| */ | |
| public static function decrement($key, $value = 1){ | |
| return \Illuminate\Cache\FileStore::decrement($key, $value); | |
| } | |
| /** | |
| * Remove all items from the cache. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function flush(){ | |
| \Illuminate\Cache\FileStore::flush(); | |
| } | |
| /** | |
| * Get the Filesystem instance. | |
| * | |
| * @return \Illuminate\Filesystem\Filesystem | |
| * @static | |
| */ | |
| public static function getFilesystem(){ | |
| return \Illuminate\Cache\FileStore::getFilesystem(); | |
| } | |
| /** | |
| * Get the working directory of the cache. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getDirectory(){ | |
| return \Illuminate\Cache\FileStore::getDirectory(); | |
| } | |
| /** | |
| * Get the cache key prefix. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getPrefix(){ | |
| return \Illuminate\Cache\FileStore::getPrefix(); | |
| } | |
| } | |
| class Cookie extends \Illuminate\Support\Facades\Cookie{ | |
| /** | |
| * Create a new cookie instance. | |
| * | |
| * @param string $name | |
| * @param string $value | |
| * @param int $minutes | |
| * @param string $path | |
| * @param string $domain | |
| * @param bool $secure | |
| * @param bool $httpOnly | |
| * @return \Symfony\Component\HttpFoundation\Cookie | |
| * @static | |
| */ | |
| public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true){ | |
| return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly); | |
| } | |
| /** | |
| * Create a cookie that lasts "forever" (five years). | |
| * | |
| * @param string $name | |
| * @param string $value | |
| * @param string $path | |
| * @param string $domain | |
| * @param bool $secure | |
| * @param bool $httpOnly | |
| * @return \Symfony\Component\HttpFoundation\Cookie | |
| * @static | |
| */ | |
| public static function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true){ | |
| return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly); | |
| } | |
| /** | |
| * Expire the given cookie. | |
| * | |
| * @param string $name | |
| * @param string $path | |
| * @param string $domain | |
| * @return \Symfony\Component\HttpFoundation\Cookie | |
| * @static | |
| */ | |
| public static function forget($name, $path = null, $domain = null){ | |
| return \Illuminate\Cookie\CookieJar::forget($name, $path, $domain); | |
| } | |
| /** | |
| * Determine if a cookie has been queued. | |
| * | |
| * @param string $key | |
| * @return bool | |
| * @static | |
| */ | |
| public static function hasQueued($key){ | |
| return \Illuminate\Cookie\CookieJar::hasQueued($key); | |
| } | |
| /** | |
| * Get a queued cookie instance. | |
| * | |
| * @param string $key | |
| * @param mixed $default | |
| * @return \Symfony\Component\HttpFoundation\Cookie | |
| * @static | |
| */ | |
| public static function queued($key, $default = null){ | |
| return \Illuminate\Cookie\CookieJar::queued($key, $default); | |
| } | |
| /** | |
| * Queue a cookie to send with the next response. | |
| * | |
| * @param mixed | |
| * @return void | |
| * @static | |
| */ | |
| public static function queue(){ | |
| \Illuminate\Cookie\CookieJar::queue(); | |
| } | |
| /** | |
| * Remove a cookie from the queue. | |
| * | |
| * @param string $name | |
| * @static | |
| */ | |
| public static function unqueue($name){ | |
| return \Illuminate\Cookie\CookieJar::unqueue($name); | |
| } | |
| /** | |
| * Set the default path and domain for the jar. | |
| * | |
| * @param string $path | |
| * @param string $domain | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setDefaultPathAndDomain($path, $domain){ | |
| return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain); | |
| } | |
| /** | |
| * Get the cookies which have been queued for the next request. | |
| * | |
| * @return array | |
| * @static | |
| */ | |
| public static function getQueuedCookies(){ | |
| return \Illuminate\Cookie\CookieJar::getQueuedCookies(); | |
| } | |
| } | |
| class Crypt extends \Illuminate\Support\Facades\Crypt{ | |
| /** | |
| * Determine if the given key and cipher combination is valid. | |
| * | |
| * @param string $key | |
| * @param string $cipher | |
| * @return bool | |
| * @static | |
| */ | |
| public static function supported($key, $cipher){ | |
| return \Illuminate\Encryption\Encrypter::supported($key, $cipher); | |
| } | |
| /** | |
| * Encrypt the given value. | |
| * | |
| * @param string $value | |
| * @return string | |
| * @static | |
| */ | |
| public static function encrypt($value){ | |
| return \Illuminate\Encryption\Encrypter::encrypt($value); | |
| } | |
| /** | |
| * Decrypt the given value. | |
| * | |
| * @param string $payload | |
| * @return string | |
| * @static | |
| */ | |
| public static function decrypt($payload){ | |
| return \Illuminate\Encryption\Encrypter::decrypt($payload); | |
| } | |
| } | |
| class Event extends \Illuminate\Support\Facades\Event{ | |
| /** | |
| * Register an event listener with the dispatcher. | |
| * | |
| * @param string|array $events | |
| * @param mixed $listener | |
| * @param int $priority | |
| * @return void | |
| * @static | |
| */ | |
| public static function listen($events, $listener, $priority = 0){ | |
| \Illuminate\Events\Dispatcher::listen($events, $listener, $priority); | |
| } | |
| /** | |
| * Determine if a given event has listeners. | |
| * | |
| * @param string $eventName | |
| * @return bool | |
| * @static | |
| */ | |
| public static function hasListeners($eventName){ | |
| return \Illuminate\Events\Dispatcher::hasListeners($eventName); | |
| } | |
| /** | |
| * Register an event and payload to be fired later. | |
| * | |
| * @param string $event | |
| * @param array $payload | |
| * @return void | |
| * @static | |
| */ | |
| public static function push($event, $payload = array()){ | |
| \Illuminate\Events\Dispatcher::push($event, $payload); | |
| } | |
| /** | |
| * Register an event subscriber with the dispatcher. | |
| * | |
| * @param object|string $subscriber | |
| * @return void | |
| * @static | |
| */ | |
| public static function subscribe($subscriber){ | |
| \Illuminate\Events\Dispatcher::subscribe($subscriber); | |
| } | |
| /** | |
| * Fire an event until the first non-null response is returned. | |
| * | |
| * @param string|object $event | |
| * @param array $payload | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function until($event, $payload = array()){ | |
| return \Illuminate\Events\Dispatcher::until($event, $payload); | |
| } | |
| /** | |
| * Flush a set of pushed events. | |
| * | |
| * @param string $event | |
| * @return void | |
| * @static | |
| */ | |
| public static function flush($event){ | |
| \Illuminate\Events\Dispatcher::flush($event); | |
| } | |
| /** | |
| * Get the event that is currently firing. | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function firing(){ | |
| return \Illuminate\Events\Dispatcher::firing(); | |
| } | |
| /** | |
| * Fire an event and call the listeners. | |
| * | |
| * @param string|object $event | |
| * @param mixed $payload | |
| * @param bool $halt | |
| * @return array|null | |
| * @static | |
| */ | |
| public static function fire($event, $payload = array(), $halt = false){ | |
| return \Illuminate\Events\Dispatcher::fire($event, $payload, $halt); | |
| } | |
| /** | |
| * Get all of the listeners for a given event name. | |
| * | |
| * @param string $eventName | |
| * @return array | |
| * @static | |
| */ | |
| public static function getListeners($eventName){ | |
| return \Illuminate\Events\Dispatcher::getListeners($eventName); | |
| } | |
| /** | |
| * Register an event listener with the dispatcher. | |
| * | |
| * @param mixed $listener | |
| * @return mixed | |
| * @static | |
| */ | |
| public static function makeListener($listener){ | |
| return \Illuminate\Events\Dispatcher::makeListener($listener); | |
| } | |
| /** | |
| * Create a class based listener using the IoC container. | |
| * | |
| * @param mixed $listener | |
| * @return \Closure | |
| * @static | |
| */ | |
| public static function createClassListener($listener){ | |
| return \Illuminate\Events\Dispatcher::createClassListener($listener); | |
| } | |
| /** | |
| * Remove a set of listeners from the dispatcher. | |
| * | |
| * @param string $event | |
| * @return void | |
| * @static | |
| */ | |
| public static function forget($event){ | |
| \Illuminate\Events\Dispatcher::forget($event); | |
| } | |
| /** | |
| * Forget all of the pushed listeners. | |
| * | |
| * @return void | |
| * @static | |
| */ | |
| public static function forgetPushed(){ | |
| \Illuminate\Events\Dispatcher::forgetPushed(); | |
| } | |
| /** | |
| * Set the queue resolver implementation. | |
| * | |
| * @param callable $resolver | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setQueueResolver($resolver){ | |
| return \Illuminate\Events\Dispatcher::setQueueResolver($resolver); | |
| } | |
| } | |
| class Hash extends \Illuminate\Support\Facades\Hash{ | |
| /** | |
| * Hash the given value. | |
| * | |
| * @param string $value | |
| * @param array $options | |
| * @return string | |
| * @throws \RuntimeException | |
| * @static | |
| */ | |
| public static function make($value, $options = array()){ | |
| return \Illuminate\Hashing\BcryptHasher::make($value, $options); | |
| } | |
| /** | |
| * Check the given plain value against a hash. | |
| * | |
| * @param string $value | |
| * @param string $hashedValue | |
| * @param array $options | |
| * @return bool | |
| * @static | |
| */ | |
| public static function check($value, $hashedValue, $options = array()){ | |
| return \Illuminate\Hashing\BcryptHasher::check($value, $hashedValue, $options); | |
| } | |
| /** | |
| * Check if the given hash has been hashed using the given options. | |
| * | |
| * @param string $hashedValue | |
| * @param array $options | |
| * @return bool | |
| * @static | |
| */ | |
| public static function needsRehash($hashedValue, $options = array()){ | |
| return \Illuminate\Hashing\BcryptHasher::needsRehash($hashedValue, $options); | |
| } | |
| /** | |
| * Set the default password work factor. | |
| * | |
| * @param int $rounds | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setRounds($rounds){ | |
| return \Illuminate\Hashing\BcryptHasher::setRounds($rounds); | |
| } | |
| } | |
| class Log extends \Illuminate\Support\Facades\Log{ | |
| /** | |
| * Adds a log record at the DEBUG level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function debug($message, $context = array()){ | |
| return \Monolog\Logger::debug($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the INFO level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function info($message, $context = array()){ | |
| return \Monolog\Logger::info($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the NOTICE level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function notice($message, $context = array()){ | |
| return \Monolog\Logger::notice($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the WARNING level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function warning($message, $context = array()){ | |
| return \Monolog\Logger::warning($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the ERROR level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function error($message, $context = array()){ | |
| return \Monolog\Logger::error($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the CRITICAL level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function critical($message, $context = array()){ | |
| return \Monolog\Logger::critical($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the ALERT level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function alert($message, $context = array()){ | |
| return \Monolog\Logger::alert($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the EMERGENCY level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function emergency($message, $context = array()){ | |
| return \Monolog\Logger::emergency($message, $context); | |
| } | |
| /** | |
| * | |
| * | |
| * @return string | |
| * @static | |
| */ | |
| public static function getName(){ | |
| return \Monolog\Logger::getName(); | |
| } | |
| /** | |
| * Pushes a handler on to the stack. | |
| * | |
| * @param \Monolog\HandlerInterface $handler | |
| * @return $this | |
| * @static | |
| */ | |
| public static function pushHandler($handler){ | |
| return \Monolog\Logger::pushHandler($handler); | |
| } | |
| /** | |
| * Pops a handler from the stack | |
| * | |
| * @return \Monolog\HandlerInterface | |
| * @static | |
| */ | |
| public static function popHandler(){ | |
| return \Monolog\Logger::popHandler(); | |
| } | |
| /** | |
| * Set handlers, replacing all existing ones. | |
| * | |
| * If a map is passed, keys will be ignored. | |
| * | |
| * @param \Monolog\HandlerInterface[] $handlers | |
| * @return $this | |
| * @static | |
| */ | |
| public static function setHandlers($handlers){ | |
| return \Monolog\Logger::setHandlers($handlers); | |
| } | |
| /** | |
| * | |
| * | |
| * @return \Monolog\HandlerInterface[] | |
| * @static | |
| */ | |
| public static function getHandlers(){ | |
| return \Monolog\Logger::getHandlers(); | |
| } | |
| /** | |
| * Adds a processor on to the stack. | |
| * | |
| * @param callable $callback | |
| * @return $this | |
| * @static | |
| */ | |
| public static function pushProcessor($callback){ | |
| return \Monolog\Logger::pushProcessor($callback); | |
| } | |
| /** | |
| * Removes the processor on top of the stack and returns it. | |
| * | |
| * @return callable | |
| * @static | |
| */ | |
| public static function popProcessor(){ | |
| return \Monolog\Logger::popProcessor(); | |
| } | |
| /** | |
| * | |
| * | |
| * @return callable[] | |
| * @static | |
| */ | |
| public static function getProcessors(){ | |
| return \Monolog\Logger::getProcessors(); | |
| } | |
| /** | |
| * Adds a log record. | |
| * | |
| * @param integer $level The logging level | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addRecord($level, $message, $context = array()){ | |
| return \Monolog\Logger::addRecord($level, $message, $context); | |
| } | |
| /** | |
| * Adds a log record at the DEBUG level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addDebug($message, $context = array()){ | |
| return \Monolog\Logger::addDebug($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the INFO level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addInfo($message, $context = array()){ | |
| return \Monolog\Logger::addInfo($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the NOTICE level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addNotice($message, $context = array()){ | |
| return \Monolog\Logger::addNotice($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the WARNING level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addWarning($message, $context = array()){ | |
| return \Monolog\Logger::addWarning($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the ERROR level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addError($message, $context = array()){ | |
| return \Monolog\Logger::addError($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the CRITICAL level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addCritical($message, $context = array()){ | |
| return \Monolog\Logger::addCritical($message, $context); | |
| } | |
| /** | |
| * Adds a log record at the ALERT level. | |
| * | |
| * @param string $message The log message | |
| * @param array $context The log context | |
| * @return Boolean Whether the record has been processed | |
| * @static | |
| */ | |
| public static function addAlert($message, $context = array()){ | |
| return \Monolog\Logger:: |