Preview: compiled.php
Size: 222.34 KB
/var/www/penneotest.bitkit.dk/httpdocs/bootstrap/cache/compiled.php
<?php
namespace Illuminate\Contracts\Container {
use Closure;
interface Container
{
public function bound($abstract);
public function alias($abstract, $alias);
public function tag($abstracts, $tags);
public function tagged($tag);
public function bind($abstract, $concrete = null, $shared = false);
public function bindIf($abstract, $concrete = null, $shared = false);
public function singleton($abstract, $concrete = null);
public function extend($abstract, Closure $closure);
public function instance($abstract, $instance);
public function when($concrete);
public function make($abstract, array $parameters = []);
public function call($callback, array $parameters = [], $defaultMethod = null);
public function resolved($abstract);
public function resolving($abstract, Closure $callback = null);
public function afterResolving($abstract, Closure $callback = null);
}
}
namespace Illuminate\Contracts\Container {
interface ContextualBindingBuilder
{
public function needs($abstract);
public function give($implementation);
}
}
namespace Illuminate\Contracts\Foundation {
use Illuminate\Contracts\Container\Container;
interface Application extends Container
{
public function version();
public function basePath();
public function environment();
public function isDownForMaintenance();
public function registerConfiguredProviders();
public function register($provider, $options = [], $force = false);
public function registerDeferredProvider($provider, $service = null);
public function boot();
public function booting($callback);
public function booted($callback);
public function getCachedCompilePath();
public function getCachedServicesPath();
}
}
namespace Illuminate\Contracts\Bus {
interface Dispatcher
{
public function dispatch($command);
public function dispatchNow($command);
public function pipeThrough(array $pipes);
}
}
namespace Illuminate\Contracts\Bus {
interface QueueingDispatcher extends Dispatcher
{
public function dispatchToQueue($command);
}
}
namespace Illuminate\Contracts\Pipeline {
use Closure;
interface Pipeline
{
public function send($traveler);
public function through($stops);
public function via($method);
public function then(Closure $destination);
}
}
namespace Illuminate\Contracts\Support {
interface Renderable
{
public function render();
}
}
namespace Illuminate\Contracts\Logging {
interface Log
{
public function alert($message, array $context = []);
public function critical($message, array $context = []);
public function error($message, array $context = []);
public function warning($message, array $context = []);
public function notice($message, array $context = []);
public function info($message, array $context = []);
public function debug($message, array $context = []);
public function log($level, $message, array $context = []);
public function useFiles($path, $level = 'debug');
public function useDailyFiles($path, $days = 0, $level = 'debug');
}
}
namespace Illuminate\Contracts\Debug {
use Exception;
interface ExceptionHandler
{
public function report(Exception $e);
public function render($request, Exception $e);
public function renderForConsole($output, Exception $e);
}
}
namespace Illuminate\Contracts\Config {
interface Repository
{
public function has($key);
public function get($key, $default = null);
public function all();
public function set($key, $value = null);
public function prepend($key, $value);
public function push($key, $value);
}
}
namespace Illuminate\Contracts\Events {
interface Dispatcher
{
public function listen($events, $listener, $priority = 0);
public function hasListeners($eventName);
public function push($event, $payload = []);
public function subscribe($subscriber);
public function until($event, $payload = []);
public function flush($event);
public function fire($event, $payload = [], $halt = false);
public function firing();
public function forget($event);
public function forgetPushed();
}
}
namespace Illuminate\Contracts\Support {
interface Arrayable
{
public function toArray();
}
}
namespace Illuminate\Contracts\Support {
interface Jsonable
{
public function toJson($options = 0);
}
}
namespace Illuminate\Contracts\Cookie {
interface Factory
{
public function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true);
public function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true);
public function forget($name, $path = null, $domain = null);
}
}
namespace Illuminate\Contracts\Cookie {
interface QueueingFactory extends Factory
{
public function queue();
public function unqueue($name);
public function getQueuedCookies();
}
}
namespace Illuminate\Contracts\Encryption {
interface Encrypter
{
public function encrypt($value);
public function decrypt($payload);
}
}
namespace Illuminate\Contracts\Queue {
interface QueueableEntity
{
public function getQueueableId();
}
}
namespace Illuminate\Contracts\Routing {
use Closure;
interface Registrar
{
public function get($uri, $action);
public function post($uri, $action);
public function put($uri, $action);
public function delete($uri, $action);
public function patch($uri, $action);
public function options($uri, $action);
public function match($methods, $uri, $action);
public function resource($name, $controller, array $options = []);
public function group(array $attributes, Closure $callback);
}
}
namespace Illuminate\Contracts\Routing {
interface ResponseFactory
{
public function make($content = '', $status = 200, array $headers = []);
public function view($view, $data = [], $status = 200, array $headers = []);
public function json($data = [], $status = 200, array $headers = [], $options = 0);
public function jsonp($callback, $data = [], $status = 200, array $headers = [], $options = 0);
public function stream($callback, $status = 200, array $headers = []);
public function download($file, $name = null, array $headers = [], $disposition = 'attachment');
public function redirectTo($path, $status = 302, $headers = [], $secure = null);
public function redirectToRoute($route, $parameters = [], $status = 302, $headers = []);
public function redirectToAction($action, $parameters = [], $status = 302, $headers = []);
public function redirectGuest($path, $status = 302, $headers = [], $secure = null);
public function redirectToIntended($default = '/', $status = 302, $headers = [], $secure = null);
}
}
namespace Illuminate\Contracts\Routing {
interface UrlGenerator
{
public function current();
public function to($path, $extra = [], $secure = null);
public function secure($path, $parameters = []);
public function asset($path, $secure = null);
public function route($name, $parameters = [], $absolute = true);
public function action($action, $parameters = [], $absolute = true);
public function setRootControllerNamespace($rootNamespace);
}
}
namespace Illuminate\Contracts\Routing {
interface UrlRoutable
{
public function getRouteKey();
public function getRouteKeyName();
}
}
namespace Illuminate\Contracts\Validation {
interface ValidatesWhenResolved
{
public function validate();
}
}
namespace Illuminate\Contracts\View {
interface Factory
{
public function exists($view);
public function file($path, $data = [], $mergeData = []);
public function make($view, $data = [], $mergeData = []);
public function share($key, $value = null);
public function composer($views, $callback, $priority = null);
public function creator($views, $callback);
public function addNamespace($namespace, $hints);
}
}
namespace Illuminate\Contracts\Support {
interface MessageProvider
{
public function getMessageBag();
}
}
namespace Illuminate\Contracts\Support {
interface MessageBag
{
public function keys();
public function add($key, $message);
public function merge($messages);
public function has($key = null);
public function first($key = null, $format = null);
public function get($key, $format = null);
public function all($format = null);
public function getFormat();
public function setFormat($format = ':message');
public function isEmpty();
public function count();
public function toArray();
}
}
namespace Illuminate\Contracts\View {
use Illuminate\Contracts\Support\Renderable;
interface View extends Renderable
{
public function name();
public function with($key, $value = null);
}
}
namespace Illuminate\Contracts\Http {
interface Kernel
{
public function bootstrap();
public function handle($request);
public function terminate($request, $response);
public function getApplication();
}
}
namespace Illuminate\Contracts\Auth {
interface Guard
{
public function check();
public function guest();
public function user();
public function id();
public function validate(array $credentials = []);
public function setUser(Authenticatable $user);
}
}
namespace Illuminate\Contracts\Auth {
interface StatefulGuard extends Guard
{
public function attempt(array $credentials = [], $remember = false, $login = true);
public function once(array $credentials = []);
public function login(Authenticatable $user, $remember = false);
public function loginUsingId($id, $remember = false);
public function onceUsingId($id);
public function viaRemember();
public function logout();
}
}
namespace Illuminate\Contracts\Auth\Access {
interface Gate
{
public function has($ability);
public function define($ability, $callback);
public function policy($class, $policy);
public function before(callable $callback);
public function allows($ability, $arguments = []);
public function denies($ability, $arguments = []);
public function check($ability, $arguments = []);
public function forUser($user);
}
}
namespace Illuminate\Contracts\Hashing {
interface Hasher
{
public function make($value, array $options = []);
public function check($value, $hashedValue, array $options = []);
public function needsRehash($hashedValue, array $options = []);
}
}
namespace Illuminate\Auth {
use Closure;
use InvalidArgumentException;
use Illuminate\Contracts\Auth\Factory as FactoryContract;
class AuthManager implements FactoryContract
{
use CreatesUserProviders;
protected $app;
protected $customCreators = [];
protected $guards = [];
protected $userResolver;
public function __construct($app)
{
$this->app = $app;
$this->userResolver = function ($guard = null) {
return $this->guard($guard)->user();
};
}
public function guard($name = null)
{
$name = $name ?: $this->getDefaultDriver();
return isset($this->guards[$name]) ? $this->guards[$name] : ($this->guards[$name] = $this->resolve($name));
}
protected function resolve($name)
{
$config = $this->getConfig($name);
if (is_null($config)) {
throw new InvalidArgumentException("Auth guard [{$name}] is not defined.");
}
if (isset($this->customCreators[$config['driver']])) {
return $this->callCustomCreator($name, $config);
} else {
$driverMethod = 'create' . ucfirst($config['driver']) . 'Driver';
if (method_exists($this, $driverMethod)) {
return $this->{$driverMethod}($name, $config);
} else {
throw new InvalidArgumentException("Auth guard driver [{$name}] is not defined.");
}
}
}
protected function callCustomCreator($name, array $config)
{
return $this->customCreators[$config['driver']]($this->app, $name, $config);
}
public function createSessionDriver($name, $config)
{
$provider = $this->createUserProvider($config['provider']);
$guard = new SessionGuard($name, $provider, $this->app['session.store']);
if (method_exists($guard, 'setCookieJar')) {
$guard->setCookieJar($this->app['cookie']);
}
if (method_exists($guard, 'setDispatcher')) {
$guard->setDispatcher($this->app['events']);
}
if (method_exists($guard, 'setRequest')) {
$guard->setRequest($this->app->refresh('request', $guard, 'setRequest'));
}
return $guard;
}
public function createTokenDriver($name, $config)
{
$guard = new TokenGuard($this->createUserProvider($config['provider']), $this->app['request']);
$this->app->refresh('request', $guard, 'setRequest');
return $guard;
}
protected function getConfig($name)
{
return $this->app['config']["auth.guards.{$name}"];
}
public function getDefaultDriver()
{
return $this->app['config']['auth.defaults.guard'];
}
public function shouldUse($name)
{
$this->setDefaultDriver($name);
$this->userResolver = function ($name = null) {
return $this->guard($name)->user();
};
}
public function setDefaultDriver($name)
{
$this->app['config']['auth.defaults.guard'] = $name;
}
public function viaRequest($driver, callable $callback)
{
return $this->extend($driver, function () use($callback) {
$guard = new RequestGuard($callback, $this->app['request']);
$this->app->refresh('request', $guard, 'setRequest');
return $guard;
});
}
public function userResolver()
{
return $this->userResolver;
}
public function resolveUsersUsing(Closure $userResolver)
{
$this->userResolver = $userResolver;
return $this;
}
public function extend($driver, Closure $callback)
{
$this->customCreators[$driver] = $callback;
return $this;
}
public function provider($name, Closure $callback)
{
$this->customProviderCreators[$name] = $callback;
return $this;
}
public function __call($method, $parameters)
{
return call_user_func_array([$this->guard(), $method], $parameters);
}
}
}
namespace Illuminate\Auth {
use RuntimeException;
use Illuminate\Support\Str;
use Illuminate\Http\Response;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Auth\StatefulGuard;
use Symfony\Component\HttpFoundation\Request;
use Illuminate\Contracts\Auth\SupportsBasicAuth;
use Illuminate\Contracts\Cookie\QueueingFactory as CookieJar;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
class SessionGuard implements StatefulGuard, SupportsBasicAuth
{
use GuardHelpers;
protected $name;
protected $lastAttempted;
protected $viaRemember = false;
protected $session;
protected $cookie;
protected $request;
protected $events;
protected $loggedOut = false;
protected $tokenRetrievalAttempted = false;
public function __construct($name, UserProvider $provider, SessionInterface $session, Request $request = null)
{
$this->name = $name;
$this->session = $session;
$this->request = $request;
$this->provider = $provider;
}
public function user()
{
if ($this->loggedOut) {
return;
}
if (!is_null($this->user)) {
return $this->user;
}
$id = $this->session->get($this->getName());
$user = null;
if (!is_null($id)) {
$user = $this->provider->retrieveById($id);
}
$recaller = $this->getRecaller();
if (is_null($user) && !is_null($recaller)) {
$user = $this->getUserByRecaller($recaller);
if ($user) {
$this->updateSession($user->getAuthIdentifier());
$this->fireLoginEvent($user, true);
}
}
return $this->user = $user;
}
public function id()
{
if ($this->loggedOut) {
return;
}
$id = $this->session->get($this->getName());
if (is_null($id) && $this->user()) {
$id = $this->user()->getAuthIdentifier();
}
return $id;
}
protected function getUserByRecaller($recaller)
{
if ($this->validRecaller($recaller) && !$this->tokenRetrievalAttempted) {
$this->tokenRetrievalAttempted = true;
list($id, $token) = explode('|', $recaller, 2);
$this->viaRemember = !is_null($user = $this->provider->retrieveByToken($id, $token));
return $user;
}
}
protected function getRecaller()
{
return $this->request->cookies->get($this->getRecallerName());
}
protected function getRecallerId()
{
if ($this->validRecaller($recaller = $this->getRecaller())) {
return head(explode('|', $recaller));
}
}
protected function validRecaller($recaller)
{
if (!is_string($recaller) || !Str::contains($recaller, '|')) {
return false;
}
$segments = explode('|', $recaller);
return count($segments) == 2 && trim($segments[0]) !== '' && trim($segments[1]) !== '';
}
public function once(array $credentials = [])
{
if ($this->validate($credentials)) {
$this->setUser($this->lastAttempted);
return true;
}
return false;
}
public function validate(array $credentials = [])
{
return $this->attempt($credentials, false, false);
}
public function basic($field = 'email', $extraConditions = [])
{
if ($this->check()) {
return;
}
if ($this->attemptBasic($this->getRequest(), $field, $extraConditions)) {
return;
}
return $this->getBasicResponse();
}
public function onceBasic($field = 'email', $extraConditions = [])
{
$credentials = $this->getBasicCredentials($this->getRequest(), $field);
if (!$this->once(array_merge($credentials, $extraConditions))) {
return $this->getBasicResponse();
}
}
protected function attemptBasic(Request $request, $field, $extraConditions = [])
{
if (!$request->getUser()) {
return false;
}
$credentials = $this->getBasicCredentials($request, $field);
return $this->attempt(array_merge($credentials, $extraConditions));
}
protected function getBasicCredentials(Request $request, $field)
{
return [$field => $request->getUser(), 'password' => $request->getPassword()];
}
protected function getBasicResponse()
{
$headers = ['WWW-Authenticate' => 'Basic'];
return new Response('Invalid credentials.', 401, $headers);
}
public function attempt(array $credentials = [], $remember = false, $login = true)
{
$this->fireAttemptEvent($credentials, $remember, $login);
$this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);
if ($this->hasValidCredentials($user, $credentials)) {
if ($login) {
$this->login($user, $remember);
}
return true;
}
if ($login) {
$this->fireFailedEvent($user, $credentials);
}
return false;
}
protected function hasValidCredentials($user, $credentials)
{
return !is_null($user) && $this->provider->validateCredentials($user, $credentials);
}
protected function fireAttemptEvent(array $credentials, $remember, $login)
{
if (isset($this->events)) {
$this->events->fire(new Events\Attempting($credentials, $remember, $login));
}
}
protected function fireFailedEvent($user, array $credentials)
{
if (isset($this->events)) {
$this->events->fire(new Events\Failed($user, $credentials));
}
}
public function attempting($callback)
{
if (isset($this->events)) {
$this->events->listen(Events\Attempting::class, $callback);
}
}
public function login(AuthenticatableContract $user, $remember = false)
{
$this->updateSession($user->getAuthIdentifier());
if ($remember) {
$this->createRememberTokenIfDoesntExist($user);
$this->queueRecallerCookie($user);
}
$this->fireLoginEvent($user, $remember);
$this->setUser($user);
}
protected function fireLoginEvent($user, $remember = false)
{
if (isset($this->events)) {
$this->events->fire(new Events\Login($user, $remember));
}
}
protected function updateSession($id)
{
$this->session->set($this->getName(), $id);
$this->session->migrate(true);
}
public function loginUsingId($id, $remember = false)
{
$user = $this->provider->retrieveById($id);
if (!is_null($user)) {
$this->login($user, $remember);
return $user;
}
return false;
}
public function onceUsingId($id)
{
$user = $this->provider->retrieveById($id);
if (!is_null($user)) {
$this->setUser($user);
return true;
}
return false;
}
protected function queueRecallerCookie(AuthenticatableContract $user)
{
$value = $user->getAuthIdentifier() . '|' . $user->getRememberToken();
$this->getCookieJar()->queue($this->createRecaller($value));
}
protected function createRecaller($value)
{
return $this->getCookieJar()->forever($this->getRecallerName(), $value);
}
public function logout()
{
$user = $this->user();
$this->clearUserDataFromStorage();
if (!is_null($this->user)) {
$this->refreshRememberToken($user);
}
if (isset($this->events)) {
$this->events->fire(new Events\Logout($user));
}
$this->user = null;
$this->loggedOut = true;
}
protected function clearUserDataFromStorage()
{
$this->session->remove($this->getName());
if (!is_null($this->getRecaller())) {
$recaller = $this->getRecallerName();
$this->getCookieJar()->queue($this->getCookieJar()->forget($recaller));
}
}
protected function refreshRememberToken(AuthenticatableContract $user)
{
$user->setRememberToken($token = Str::random(60));
$this->provider->updateRememberToken($user, $token);
}
protected function createRememberTokenIfDoesntExist(AuthenticatableContract $user)
{
if (empty($user->getRememberToken())) {
$this->refreshRememberToken($user);
}
}
public function getCookieJar()
{
if (!isset($this->cookie)) {
throw new RuntimeException('Cookie jar has not been set.');
}
return $this->cookie;
}
public function setCookieJar(CookieJar $cookie)
{
$this->cookie = $cookie;
}
public function getDispatcher()
{
return $this->events;
}
public function setDispatcher(Dispatcher $events)
{
$this->events = $events;
}
public function getSession()
{
return $this->session;
}
public function getProvider()
{
return $this->provider;
}
public function setProvider(UserProvider $provider)
{
$this->provider = $provider;
}
public function getUser()
{
return $this->user;
}
public function setUser(AuthenticatableContract $user)
{
$this->user = $user;
$this->loggedOut = false;
return $this;
}
public function getRequest()
{
return $this->request ?: Request::createFromGlobals();
}
public function setRequest(Request $request)
{
$this->request = $request;
return $this;
}
public function getLastAttempted()
{
return $this->lastAttempted;
}
public function getName()
{
return 'login_' . $this->name . '_' . sha1(static::class);
}
public function getRecallerName()
{
return 'remember_' . $this->name . '_' . sha1(static::class);
}
public function viaRemember()
{
return $this->viaRemember;
}
}
}
namespace Illuminate\Auth\Access {
use Illuminate\Support\Str;
use InvalidArgumentException;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Auth\Access\Gate as GateContract;
class Gate implements GateContract
{
use HandlesAuthorization;
protected $container;
protected $userResolver;
protected $abilities = [];
protected $policies = [];
protected $beforeCallbacks = [];
protected $afterCallbacks = [];
public function __construct(Container $container, callable $userResolver, array $abilities = [], array $policies = [], array $beforeCallbacks = [], array $afterCallbacks = [])
{
$this->policies = $policies;
$this->container = $container;
$this->abilities = $abilities;
$this->userResolver = $userResolver;
$this->afterCallbacks = $afterCallbacks;
$this->beforeCallbacks = $beforeCallbacks;
}
public function has($ability)
{
return isset($this->abilities[$ability]);
}
public function define($ability, $callback)
{
if (is_callable($callback)) {
$this->abilities[$ability] = $callback;
} elseif (is_string($callback) && Str::contains($callback, '@')) {
$this->abilities[$ability] = $this->buildAbilityCallback($callback);
} else {
throw new InvalidArgumentException("Callback must be a callable or a 'Class@method' string.");
}
return $this;
}
protected function buildAbilityCallback($callback)
{
return function () use($callback) {
list($class, $method) = explode('@', $callback);
return call_user_func_array([$this->resolvePolicy($class), $method], func_get_args());
};
}
public function policy($class, $policy)
{
$this->policies[$class] = $policy;
return $this;
}
public function before(callable $callback)
{
$this->beforeCallbacks[] = $callback;
return $this;
}
public function after(callable $callback)
{
$this->afterCallbacks[] = $callback;
return $this;
}
public function allows($ability, $arguments = [])
{
return $this->check($ability, $arguments);
}
public function denies($ability, $arguments = [])
{
return !$this->allows($ability, $arguments);
}
public function check($ability, $arguments = [])
{
try {
$result = $this->raw($ability, $arguments);
} catch (AuthorizationException $e) {
return false;
}
return (bool) $result;
}
public function authorize($ability, $arguments = [])
{
$result = $this->raw($ability, $arguments);
if ($result instanceof Response) {
return $result;
}
return $result ? $this->allow() : $this->deny();
}
protected function raw($ability, $arguments = [])
{
if (!($user = $this->resolveUser())) {
return false;
}
$arguments = is_array($arguments) ? $arguments : [$arguments];
if (is_null($result = $this->callBeforeCallbacks($user, $ability, $arguments))) {
$result = $this->callAuthCallback($user, $ability, $arguments);
}
$this->callAfterCallbacks($user, $ability, $arguments, $result);
return $result;
}
protected function callAuthCallback($user, $ability, array $arguments)
{
$callback = $this->resolveAuthCallback($user, $ability, $arguments);
return call_user_func_array($callback, array_merge([$user], $arguments));
}
protected function callBeforeCallbacks($user, $ability, array $arguments)
{
$arguments = array_merge([$user, $ability], [$arguments]);
foreach ($this->beforeCallbacks as $before) {
if (!is_null($result = call_user_func_array($before, $arguments))) {
return $result;
}
}
}
protected function callAfterCallbacks($user, $ability, array $arguments, $result)
{
$arguments = array_merge([$user, $ability, $result], [$arguments]);
foreach ($this->afterCallbacks as $after) {
call_user_func_array($after, $arguments);
}
}
protected function resolveAuthCallback($user, $ability, array $arguments)
{
if ($this->firstArgumentCorrespondsToPolicy($arguments)) {
return $this->resolvePolicyCallback($user, $ability, $arguments);
} elseif (isset($this->abilities[$ability])) {
return $this->abilities[$ability];
} else {
return function () {
return false;
};
}
}
protected function firstArgumentCorrespondsToPolicy(array $arguments)
{
if (!isset($arguments[0])) {
return false;
}
if (is_object($arguments[0])) {
return isset($this->policies[get_class($arguments[0])]);
}
return is_string($arguments[0]) && isset($this->policies[$arguments[0]]);
}
protected function resolvePolicyCallback($user, $ability, array $arguments)
{
return function () use($user, $ability, $arguments) {
$instance = $this->getPolicyFor($arguments[0]);
if (method_exists($instance, 'before')) {
$beforeArguments = array_merge([$user, $ability], $arguments);
$result = call_user_func_array([$instance, 'before'], $beforeArguments);
if (!is_null($result)) {
return $result;
}
}
if (strpos($ability, '-') !== false) {
$ability = Str::camel($ability);
}
if (!is_callable([$instance, $ability])) {
return false;
}
return call_user_func_array([$instance, $ability], array_merge([$user], $arguments));
};
}
public function getPolicyFor($class)
{
if (is_object($class)) {
$class = get_class($class);
}
if (!isset($this->policies[$class])) {
throw new InvalidArgumentException("Policy not defined for [{$class}].");
}
return $this->resolvePolicy($this->policies[$class]);
}
public function resolvePolicy($class)
{
return $this->container->make($class);
}
public function forUser($user)
{
$callback = function () use($user) {
return $user;
};
return new static($this->container, $callback, $this->abilities, $this->policies, $this->beforeCallbacks, $this->afterCallbacks);
}
protected function resolveUser()
{
return call_user_func($this->userResolver);
}
}
}
namespace Illuminate\Contracts\Auth {
interface UserProvider
{
public function retrieveById($identifier);
public function retrieveByToken($identifier, $token);
public function updateRememberToken(Authenticatable $user, $token);
public function retrieveByCredentials(array $credentials);
public function validateCredentials(Authenticatable $user, array $credentials);
}
}
namespace Illuminate\Auth {
use Illuminate\Support\Str;
use Illuminate\Contracts\Auth\UserProvider;
use Illuminate\Contracts\Hashing\Hasher as HasherContract;
use Illuminate\Contracts\Auth\Authenticatable as UserContract;
class EloquentUserProvider implements UserProvider
{
protected $hasher;
protected $model;
public function __construct(HasherContract $hasher, $model)
{
$this->model = $model;
$this->hasher = $hasher;
}
public function retrieveById($identifier)
{
return $this->createModel()->newQuery()->find($identifier);
}
public function retrieveByToken($identifier, $token)
{
$model = $this->createModel();
return $model->newQuery()->where($model->getAuthIdentifierName(), $identifier)->where($model->getRememberTokenName(), $token)->first();
}
public function updateRememberToken(UserContract $user, $token)
{
$user->setRememberToken($token);
$user->save();
}
public function retrieveByCredentials(array $credentials)
{
if (empty($credentials)) {
return;
}
$query = $this->createModel()->newQuery();
foreach ($credentials as $key => $value) {
if (!Str::contains($key, 'password')) {
$query->where($key, $value);
}
}
return $query->first();
}
public function validateCredentials(UserContract $user, array $credentials)
{
$plain = $credentials['password'];
return $this->hasher->check($plain, $user->getAuthPassword());
}
public function createModel()
{
$class = '\\' . ltrim($this->model, '\\');
return new $class();
}
public function getHasher()
{
return $this->hasher;
}
public function setHasher(HasherContract $hasher)
{
$this->hasher = $hasher;
return $this;
}
public function getModel()
{
return $this->model;
}
public function setModel($model)
{
$this->model = $model;
return $this;
}
}
}
namespace Illuminate\Container {
use Closure;
use ArrayAccess;
use ReflectionClass;
use ReflectionMethod;
use ReflectionFunction;
use ReflectionParameter;
use InvalidArgumentException;
use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Contracts\Container\Container as ContainerContract;
class Container implements ArrayAccess, ContainerContract
{
protected static $instance;
protected $resolved = [];
protected $bindings = [];
protected $instances = [];
protected $aliases = [];
protected $extenders = [];
protected $tags = [];
protected $buildStack = [];
public $contextual = [];
protected $reboundCallbacks = [];
protected $globalResolvingCallbacks = [];
protected $globalAfterResolvingCallbacks = [];
protected $resolvingCallbacks = [];
protected $afterResolvingCallbacks = [];
public function when($concrete)
{
$concrete = $this->normalize($concrete);
return new ContextualBindingBuilder($this, $concrete);
}
public function bound($abstract)
{
$abstract = $this->normalize($abstract);
return isset($this->bindings[$abstract]) || isset($this->instances[$abstract]) || $this->isAlias($abstract);
}
public function resolved($abstract)
{
$abstract = $this->normalize($abstract);
if ($this->isAlias($abstract)) {
$abstract = $this->getAlias($abstract);
}
return isset($this->resolved[$abstract]) || isset($this->instances[$abstract]);
}
public function isAlias($name)
{
return isset($this->aliases[$this->normalize($name)]);
}
public function bind($abstract, $concrete = null, $shared = false)
{
$abstract = $this->normalize($abstract);
$concrete = $this->normalize($concrete);
if (is_array($abstract)) {
list($abstract, $alias) = $this->extractAlias($abstract);
$this->alias($abstract, $alias);
}
$this->dropStaleInstances($abstract);
if (is_null($concrete)) {
$concrete = $abstract;
}
if (!$concrete instanceof Closure) {
$concrete = $this->getClosure($abstract, $concrete);
}
$this->bindings[$abstract] = compact('concrete', 'shared');
if ($this->resolved($abstract)) {
$this->rebound($abstract);
}
}
protected function getClosure($abstract, $concrete)
{
return function ($c, $parameters = []) use($abstract, $concrete) {
$method = $abstract == $concrete ? 'build' : 'make';
return $c->{$method}($concrete, $parameters);
};
}
public function addContextualBinding($concrete, $abstract, $implementation)
{
$this->contextual[$this->normalize($concrete)][$this->normalize($abstract)] = $this->normalize($implementation);
}
public function bindIf($abstract, $concrete = null, $shared = false)
{
if (!$this->bound($abstract)) {
$this->bind($abstract, $concrete, $shared);
}
}
public function singleton($abstract, $concrete = null)
{
$this->bind($abstract, $concrete, true);
}
public function share(Closure $closure)
{
return function ($container) use($closure) {
static $object;
if (is_null($object)) {
$object = $closure($container);
}
return $object;
};
}
public function extend($abstract, Closure $closure)
{
$abstract = $this->normalize($abstract);
if (isset($this->instances[$abstract])) {
$this->instances[$abstract] = $closure($this->instances[$abstract], $this);
$this->rebound($abstract);
} else {
$this->extenders[$abstract][] = $closure;
}
}
public function instance($abstract, $instance)
{
$abstract = $this->normalize($abstract);
if (is_array($abstract)) {
list($abstract, $alias) = $this->extractAlias($abstract);
$this->alias($abstract, $alias);
}
unset($this->aliases[$abstract]);
$bound = $this->bound($abstract);
$this->instances[$abstract] = $instance;
if ($bound) {
$this->rebound($abstract);
}
}
public function tag($abstracts, $tags)
{
$tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);
foreach ($tags as $tag) {
if (!isset($this->tags[$tag])) {
$this->tags[$tag] = [];
}
foreach ((array) $abstracts as $abstract) {
$this->tags[$tag][] = $this->normalize($abstract);
}
}
}
public function tagged($tag)
{
$results = [];
if (isset($this->tags[$tag])) {
foreach ($this->tags[$tag] as $abstract) {
$results[] = $this->make($abstract);
}
}
return $results;
}
public function alias($abstract, $alias)
{
$this->aliases[$alias] = $this->normalize($abstract);
}
protected function extractAlias(array $definition)
{
return [key($definition), current($definition)];
}
public function rebinding($abstract, Closure $callback)
{
$this->reboundCallbacks[$this->normalize($abstract)][] = $callback;
if ($this->bound($abstract)) {
return $this->make($abstract);
}
}
public function refresh($abstract, $target, $method)
{
return $this->rebinding($this->normalize($abstract), function ($app, $instance) use($target, $method) {
$target->{$method}($instance);
});
}
protected function rebound($abstract)
{
$instance = $this->make($abstract);
foreach ($this->getReboundCallbacks($abstract) as $callback) {
call_user_func($callback, $this, $instance);
}
}
protected function getReboundCallbacks($abstract)
{
if (isset($this->reboundCallbacks[$abstract])) {
return $this->reboundCallbacks[$abstract];
}
return [];
}
public function wrap(Closure $callback, array $parameters = [])
{
return function () use($callback, $parameters) {
return $this->call($callback, $parameters);
};
}
public function call($callback, array $parameters = [], $defaultMethod = null)
{
if ($this->isCallableWithAtSign($callback) || $defaultMethod) {
return $this->callClass($callback, $parameters, $defaultMethod);
}
$dependencies = $this->getMethodDependencies($callback, $parameters);
return call_user_func_array($callback, $dependencies);
}
protected function isCallableWithAtSign($callback)
{
return is_string($callback) && strpos($callback, '@') !== false;
}
protected function getMethodDependencies($callback, array $parameters = [])
{
$dependencies = [];
foreach ($this->getCallReflector($callback)->getParameters() as $parameter) {
$this->addDependencyForCallParameter($parameter, $parameters, $dependencies);
}
return array_merge($dependencies, $parameters);
}
protected function getCallReflector($callback)
{
if (is_string($callback) && strpos($callback, '::') !== false) {
$callback = explode('::', $callback);
}
if (is_array($callback)) {
return new ReflectionMethod($callback[0], $callback[1]);
}
return new ReflectionFunction($callback);
}
protected function addDependencyForCallParameter(ReflectionParameter $parameter, array &$parameters, &$dependencies)
{
if (array_key_exists($parameter->name, $parameters)) {
$dependencies[] = $parameters[$parameter->name];
unset($parameters[$parameter->name]);
} elseif ($parameter->getClass()) {
$dependencies[] = $this->make($parameter->getClass()->name);
} elseif ($parameter->isDefaultValueAvailable()) {
$dependencies[] = $parameter->getDefaultValue();
}
}
protected function callClass($target, array $parameters = [], $defaultMethod = null)
{
$segments = explode('@', $target);
$method = count($segments) == 2 ? $segments[1] : $defaultMethod;
if (is_null($method)) {
throw new InvalidArgumentException('Method not provided.');
}
return $this->call([$this->make($segments[0]), $method], $parameters);
}
public function make($abstract, array $parameters = [])
{
$abstract = $this->getAlias($this->normalize($abstract));
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
$concrete = $this->getConcrete($abstract);
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete, $parameters);
} else {
$object = $this->make($concrete, $parameters);
}
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
if ($this->isShared($abstract)) {
$this->instances[$abstract] = $object;
}
$this->fireResolvingCallbacks($abstract, $object);
$this->resolved[$abstract] = true;
return $object;
}
protected function getConcrete($abstract)
{
if (!is_null($concrete = $this->getContextualConcrete($abstract))) {
return $concrete;
}
if (!isset($this->bindings[$abstract])) {
return $abstract;
}
return $this->bindings[$abstract]['concrete'];
}
protected function getContextualConcrete($abstract)
{
if (isset($this->contextual[end($this->buildStack)][$abstract])) {
return $this->contextual[end($this->buildStack)][$abstract];
}
}
protected function normalize($service)
{
return is_string($service) ? ltrim($service, '\\') : $service;
}
protected function getExtenders($abstract)
{
if (isset($this->extenders[$abstract])) {
return $this->extenders[$abstract];
}
return [];
}
public function build($concrete, array $parameters = [])
{
if ($concrete instanceof Closure) {
return $concrete($this, $parameters);
}
$reflector = new ReflectionClass($concrete);
if (!$reflector->isInstantiable()) {
if (!empty($this->buildStack)) {
$previous = implode(', ', $this->buildStack);
$message = "Target [{$concrete}] is not instantiable while building [{$previous}].";
} else {
$message = "Target [{$concrete}] is not instantiable.";
}
throw new BindingResolutionException($message);
}
$this->buildStack[] = $concrete;
$constructor = $reflector->getConstructor();
if (is_null($constructor)) {
array_pop($this->buildStack);
return new $concrete();
}
$dependencies = $constructor->getParameters();
$parameters = $this->keyParametersByArgument($dependencies, $parameters);
$instances = $this->getDependencies($dependencies, $parameters);
array_pop($this->buildStack);
return $reflector->newInstanceArgs($instances);
}
protected function getDependencies(array $parameters, array $primitives = [])
{
$dependencies = [];
foreach ($parameters as $parameter) {
$dependency = $parameter->getClass();
if (array_key_exists($parameter->name, $primitives)) {
$dependencies[] = $primitives[$parameter->name];
} elseif (is_null($dependency)) {
$dependencies[] = $this->resolveNonClass($parameter);
} else {
$dependencies[] = $this->resolveClass($parameter);
}
}
return $dependencies;
}
protected function resolveNonClass(ReflectionParameter $parameter)
{
if (!is_null($concrete = $this->getContextualConcrete('$' . $parameter->name))) {
if ($concrete instanceof Closure) {
return call_user_func($concrete, $this);
} else {
return $concrete;
}
}
if ($parameter->isDefaultValueAvailable()) {
return $parameter->getDefaultValue();
}
$message = "Unresolvable dependency resolving [{$parameter}] in class {$parameter->getDeclaringClass()->getName()}";
throw new BindingResolutionException($message);
}
protected function resolveClass(ReflectionParameter $parameter)
{
try {
return $this->make($parameter->getClass()->name);
} catch (BindingResolutionException $e) {
if ($parameter->isOptional()) {
return $parameter->getDefaultValue();
}
throw $e;
}
}
protected function keyParametersByArgument(array $dependencies, array $parameters)
{
foreach ($parameters as $key => $value) {
if (is_numeric($key)) {
unset($parameters[$key]);
$parameters[$dependencies[$key]->name] = $value;
}
}
return $parameters;
}
public function resolving($abstract, Closure $callback = null)
{
if ($callback === null && $abstract instanceof Closure) {
$this->resolvingCallback($abstract);
} else {
$this->resolvingCallbacks[$this->normalize($abstract)][] = $callback;
}
}
public function afterResolving($abstract, Closure $callback = null)
{
if ($abstract instanceof Closure && $callback === null) {
$this->afterResolvingCallback($abstract);
} else {
$this->afterResolvingCallbacks[$this->normalize($abstract)][] = $callback;
}
}
protected function resolvingCallback(Closure $callback)
{
$abstract = $this->getFunctionHint($callback);
if ($abstract) {
$this->resolvingCallbacks[$abstract][] = $callback;
} else {
$this->globalResolvingCallbacks[] = $callback;
}
}
protected function afterResolvingCallback(Closure $callback)
{
$abstract = $this->getFunctionHint($callback);
if ($abstract) {
$this->afterResolvingCallbacks[$abstract][] = $callback;
} else {
$this->globalAfterResolvingCallbacks[] = $callback;
}
}
protected function getFunctionHint(Closure $callback)
{
$function = new ReflectionFunction($callback);
if ($function->getNumberOfParameters() == 0) {
return;
}
$expected = $function->getParameters()[0];
if (!$expected->getClass()) {
return;
}
return $expected->getClass()->name;
}
protected function fireResolvingCallbacks($abstract, $object)
{
$this->fireCallbackArray($object, $this->globalResolvingCallbacks);
$this->fireCallbackArray($object, $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks));
$this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
$this->fireCallbackArray($object, $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks));
}
protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
{
$results = [];
foreach ($callbacksPerType as $type => $callbacks) {
if ($type === $abstract || $object instanceof $type) {
$results = array_merge($results, $callbacks);
}
}
return $results;
}
protected function fireCallbackArray($object, array $callbacks)
{
foreach ($callbacks as $callback) {
$callback($object, $this);
}
}
public function isShared($abstract)
{
$abstract = $this->normalize($abstract);
if (isset($this->instances[$abstract])) {
return true;
}
if (!isset($this->bindings[$abstract]['shared'])) {
return false;
}
return $this->bindings[$abstract]['shared'] === true;
}
protected function isBuildable($concrete, $abstract)
{
return $concrete === $abstract || $concrete instanceof Closure;
}
protected function getAlias($abstract)
{
if (!isset($this->aliases[$abstract])) {
return $abstract;
}
return $this->getAlias($this->aliases[$abstract]);
}
public function getBindings()
{
return $this->bindings;
}
protected function dropStaleInstances($abstract)
{
unset($this->instances[$abstract], $this->aliases[$abstract]);
}
public function forgetInstance($abstract)
{
unset($this->instances[$this->normalize($abstract)]);
}
public function forgetInstances()
{
$this->instances = [];
}
public function flush()
{
$this->aliases = [];
$this->resolved = [];
$this->bindings = [];
$this->instances = [];
}
public static function getInstance()
{
return static::$instance;
}
public static function setInstance(ContainerContract $container)
{
static::$instance = $container;
}
public function offsetExists($key)
{
return $this->bound($key);
}
public function offsetGet($key)
{
return $this->make($key);
}
public function offsetSet($key, $value)
{
if (!$value instanceof Closure) {
$value = function () use($value) {
return $value;
};
}
$this->bind($key, $value);
}
public function offsetUnset($key)
{
$key = $this->normalize($key);
unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
}
public function __get($key)
{
return $this[$key];
}
public function __set($key, $value)
{
$this[$key] = $value;
}
}
}
namespace Symfony\Component\HttpKernel {
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
interface HttpKernelInterface
{
const MASTER_REQUEST = 1;
const SUB_REQUEST = 2;
public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true);
}
}
namespace Symfony\Component\HttpKernel {
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
interface TerminableInterface
{
public function terminate(Request $request, Response $response);
}
}
namespace Illuminate\Foundation {
use Closure;
use RuntimeException;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Http\Request;
use Illuminate\Container\Container;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\ServiceProvider;
use Illuminate\Events\EventServiceProvider;
use Illuminate\Routing\RoutingServiceProvider;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Illuminate\Contracts\Foundation\Application as ApplicationContract;
class Application extends Container implements ApplicationContract, HttpKernelInterface
{
const VERSION = '5.2.45';
protected $basePath;
protected $hasBeenBootstrapped = false;
protected $booted = false;
protected $bootingCallbacks = [];
protected $bootedCallbacks = [];
protected $terminatingCallbacks = [];
protected $serviceProviders = [];
protected $loadedProviders = [];
protected $deferredServices = [];
protected $monologConfigurator;
protected $databasePath;
protected $storagePath;
protected $environmentPath;
protected $environmentFile = '.env';
protected $namespace = null;
public function __construct($basePath = null)
{
$this->registerBaseBindings();
$this->registerBaseServiceProviders();
$this->registerCoreContainerAliases();
if ($basePath) {
$this->setBasePath($basePath);
}
}
public function version()
{
return static::VERSION;
}
protected function registerBaseBindings()
{
static::setInstance($this);
$this->instance('app', $this);
$this->instance('Illuminate\\Container\\Container', $this);
}
protected function registerBaseServiceProviders()
{
$this->register(new EventServiceProvider($this));
$this->register(new RoutingServiceProvider($this));
}
public function bootstrapWith(array $bootstrappers)
{
$this->hasBeenBootstrapped = true;
foreach ($bootstrappers as $bootstrapper) {
$this['events']->fire('bootstrapping: ' . $bootstrapper, [$this]);
$this->make($bootstrapper)->bootstrap($this);
$this['events']->fire('bootstrapped: ' . $bootstrapper, [$this]);
}
}
public function afterLoadingEnvironment(Closure $callback)
{
return $this->afterBootstrapping('Illuminate\\Foundation\\Bootstrap\\DetectEnvironment', $callback);
}
public function beforeBootstrapping($bootstrapper, Closure $callback)
{
$this['events']->listen('bootstrapping: ' . $bootstrapper, $callback);
}
public function afterBootstrapping($bootstrapper, Closure $callback)
{
$this['events']->listen('bootstrapped: ' . $bootstrapper, $callback);
}
public function hasBeenBootstrapped()
{
return $this->hasBeenBootstrapped;
}
public function setBasePath($basePath)
{
$this->basePath = rtrim($basePath, '\\/');
$this->bindPathsInContainer();
return $this;
}
protected function bindPathsInContainer()
{
$this->instance('path', $this->path());
$this->instance('path.base', $this->basePath());
$this->instance('path.lang', $this->langPath());
$this->instance('path.config', $this->configPath());
$this->instance('path.public', $this->publicPath());
$this->instance('path.storage', $this->storagePath());
$this->instance('path.database', $this->databasePath());
$this->instance('path.bootstrap', $this->bootstrapPath());
}
public function path()
{
return $this->basePath . DIRECTORY_SEPARATOR . 'app';
}
public function basePath()
{
return $this->basePath;
}
public function bootstrapPath()
{
return $this->basePath . DIRECTORY_SEPARATOR . 'bootstrap';
}
public function configPath()
{
return $this->basePath . DIRECTORY_SEPARATOR . 'config';
}
public function databasePath()
{
return $this->databasePath ?: $this->basePath . DIRECTORY_SEPARATOR . 'database';
}
public function useDatabasePath($path)
{
$this->databasePath = $path;
$this->instance('path.database', $path);
return $this;
}
public function langPath()
{
return $this->basePath . DIRECTORY_SEPARATOR . 'resources' . DIRECTORY_SEPARATOR . 'lang';
}
public function publicPath()
{
return $this->basePath . DIRECTORY_SEPARATOR . 'public';
}
public function storagePath()
{
return $this->storagePath ?: $this->basePath . DIRECTORY_SEPARATOR . 'storage';
}
public function useStoragePath($path)
{
$this->storagePath = $path;
$this->instance('path.storage', $path);
return $this;
}
public function environmentPath()
{
return $this->environmentPath ?: $this->basePath;
}
public function useEnvironmentPath($path)
{
$this->environmentPath = $path;
return $this;
}
public function loadEnvironmentFrom($file)
{
$this->environmentFile = $file;
return $this;
}
public function environmentFile()
{
return $this->environmentFile ?: '.env';
}
public function environmentFilePath()
{
return $this->environmentPath() . '/' . $this->environmentFile();
}
public function environment()
{
if (func_num_args() > 0) {
$patterns = is_array(func_get_arg(0)) ? func_get_arg(0) : func_get_args();
foreach ($patterns as $pattern) {
if (Str::is($pattern, $this['env'])) {
return true;
}
}
return false;
}
return $this['env'];
}
public function isLocal()
{
return $this['env'] == 'local';
}
public function detectEnvironment(Closure $callback)
{
$args = isset($_SERVER['argv']) ? $_SERVER['argv'] : null;
return $this['env'] = (new EnvironmentDetector())->detect($callback, $args);
}
public function runningInConsole()
{
return php_sapi_name() == 'cli';
}
public function runningUnitTests()
{
return $this['env'] == 'testing';
}
public function registerConfiguredProviders()
{
$manifestPath = $this->getCachedServicesPath();
(new ProviderRepository($this, new Filesystem(), $manifestPath))->load($this->config['app.providers']);
}
public function register($provider, $options = [], $force = false)
{
if (($registered = $this->getProvider($provider)) && !$force) {
return $registered;
}
if (is_string($provider)) {
$provider = $this->resolveProviderClass($provider);
}
$provider->register();
foreach ($options as $key => $value) {
$this[$key] = $value;
}
$this->markAsRegistered($provider);
if ($this->booted) {
$this->bootProvider($provider);
}
return $provider;
}
public function getProvider($provider)
{
$name = is_string($provider) ? $provider : get_class($provider);
return Arr::first($this->serviceProviders, function ($key, $value) use($name) {
return $value instanceof $name;
});
}
public function resolveProviderClass($provider)
{
return new $provider($this);
}
protected function markAsRegistered($provider)
{
$this['events']->fire($class = get_class($provider), [$provider]);
$this->serviceProviders[] = $provider;
$this->loadedProviders[$class] = true;
}
public function loadDeferredProviders()
{
foreach ($this->deferredServices as $service => $provider) {
$this->loadDeferredProvider($service);
}
$this->deferredServices = [];
}
public function loadDeferredProvider($service)
{
if (!isset($this->deferredServices[$service])) {
return;
}
$provider = $this->deferredServices[$service];
if (!isset($this->loadedProviders[$provider])) {
$this->registerDeferredProvider($provider, $service);
}
}
public function registerDeferredProvider($provider, $service = null)
{
if ($service) {
unset($this->deferredServices[$service]);
}
$this->register($instance = new $provider($this));
if (!$this->booted) {
$this->booting(function () use($instance) {
$this->bootProvider($instance);
});
}
}
public function make($abstract, array $parameters = [])
{
$abstract = $this->getAlias($abstract);
if (isset($this->deferredServices[$abstract])) {
$this->loadDeferredProvider($abstract);
}
return parent::make($abstract, $parameters);
}
public function bound($abstract)
{
return isset($this->deferredServices[$abstract]) || parent::bound($abstract);
}
public function isBooted()
{
return $this->booted;
}
public function boot()
{
if ($this->booted) {
return;
}
$this->fireAppCallbacks($this->bootingCallbacks);
array_walk($this->serviceProviders, function ($p) {
$this->bootProvider($p);
});
$this->booted = true;
$this->fireAppCallbacks($this->bootedCallbacks);
}
protected function bootProvider(ServiceProvider $provider)
{
if (method_exists($provider, 'boot')) {
return $this->call([$provider, 'boot']);
}
}
public function booting($callback)
{
$this->bootingCallbacks[] = $callback;
}
public function booted($callback)
{
$this->bootedCallbacks[] = $callback;
if ($this->isBooted()) {
$this->fireAppCallbacks([$callback]);
}
}
protected function fireAppCallbacks(array $callbacks)
{
foreach ($callbacks as $callback) {
call_user_func($callback, $this);
}
}
public function handle(SymfonyRequest $request, $type = self::MASTER_REQUEST, $catch = true)
{
return $this['Illuminate\\Contracts\\Http\\Kernel']->handle(Request::createFromBase($request));
}
public function shouldSkipMiddleware()
{
return $this->bound('middleware.disable') && $this->make('middleware.disable') === true;
}
public function configurationIsCached()
{
return file_exists($this->getCachedConfigPath());
}
public function getCachedConfigPath()
{
return $this->bootstrapPath() . '/cache/config.php';
}
public function routesAreCached()
{
return $this['files']->exists($this->getCachedRoutesPath());
}
public function getCachedRoutesPath()
{
return $this->bootstrapPath() . '/cache/routes.php';
}
public function getCachedCompilePath()
{
return $this->bootstrapPath() . '/cache/compiled.php';
}
public function getCachedServicesPath()
{
return $this->bootstrapPath() . '/cache/services.php';
}
public function isDownForMaintenance()
{
return file_exists($this->storagePath() . '/framework/down');
}
public function abort($code, $message = '', array $headers = [])
{
if ($code == 404) {
throw new NotFoundHttpException($message);
}
throw new HttpException($code, $message, null, $headers);
}
public function terminating(Closure $callback)
{
$this->terminatingCallbacks[] = $callback;
return $this;
}
public function terminate()
{
foreach ($this->terminatingCallbacks as $terminating) {
$this->call($terminating);
}
}
public function getLoadedProviders()
{
return $this->loadedProviders;
}
public function getDeferredServices()
{
return $this->deferredServices;
}
public function setDeferredServices(array $services)
{
$this->deferredServices = $services;
}
public function addDeferredServices(array $services)
{
$this->deferredServices = array_merge($this->deferredServices, $services);
}
public function isDeferredService($service)
{
return isset($this->deferredServices[$service]);
}
public function configureMonologUsing(callable $callback)
{
$this->monologConfigurator = $callback;
return $this;
}
public function hasMonologConfigurator()
{
return !is_null($this->monologConfigurator);
}
public function getMonologConfigurator()
{
return $this->monologConfigurator;
}
public function getLocale()
{
return $this['config']->get('app.locale');
}
public function setLocale($locale)
{
$this['config']->set('app.locale', $locale);
$this['translator']->setLocale($locale);
$this['events']->fire('locale.changed', [$locale]);
}
public function isLocale($locale)
{
return $this->getLocale() == $locale;
}
public function registerCoreContainerAliases()
{
$aliases = ['app' => ['Illuminate\\Foundation\\Application', 'Illuminate\\Contracts\\Container\\Container', 'Illuminate\\Contracts\\Foundation\\Application'], 'auth' => ['Illuminate\\Auth\\AuthManager', 'Illuminate\\Contracts\\Auth\\Factory'], 'auth.driver' => ['Illuminate\\Contracts\\Auth\\Guard'], 'blade.compiler' => ['Illuminate\\View\\Compilers\\BladeCompiler'], 'cache' => ['Illuminate\\Cache\\CacheManager', 'Illuminate\\Contracts\\Cache\\Factory'], 'cache.store' => ['Illuminate\\Cache\\Repository', 'Illuminate\\Contracts\\Cache\\Repository'], 'config' => ['Illuminate\\Config\\Repository', 'Illuminate\\Contracts\\Config\\Repository'], 'cookie' => ['Illuminate\\Cookie\\CookieJar', 'Illuminate\\Contracts\\Cookie\\Factory', 'Illuminate\\Contracts\\Cookie\\QueueingFactory'], 'encrypter' => ['Illuminate\\Encryption\\Encrypter', 'Illuminate\\Contracts\\Encryption\\Encrypter'], 'db' => ['Illuminate\\Database\\DatabaseManager'], 'db.connection' => ['Illuminate\\Database\\Connection', 'Illuminate\\Database\\ConnectionInterface'], 'events' => ['Illuminate\\Events\\Dispatcher', 'Illuminate\\Contracts\\Events\\Dispatcher'], 'files' => ['Illuminate\\Filesystem\\Filesystem'], 'filesystem' => ['Illuminate\\Filesystem\\FilesystemManager', 'Illuminate\\Contracts\\Filesystem\\Factory'], 'filesystem.disk' => ['Illuminate\\Contracts\\Filesystem\\Filesystem'], 'filesystem.cloud' => ['Illuminate\\Contracts\\Filesystem\\Cloud'], 'hash' => ['Illuminate\\Contracts\\Hashing\\Hasher'], 'translator' => ['Illuminate\\Translation\\Translator', 'Symfony\\Component\\Translation\\TranslatorInterface'], 'log' => ['Illuminate\\Log\\Writer', 'Illuminate\\Contracts\\Logging\\Log', 'Psr\\Log\\LoggerInterface'], 'mailer' => ['Illuminate\\Mail\\Mailer', 'Illuminate\\Contracts\\Mail\\Mailer', 'Illuminate\\Contracts\\Mail\\MailQueue'], 'auth.password' => ['Illuminate\\Auth\\Passwords\\PasswordBrokerManager', 'Illuminate\\Contracts\\Auth\\PasswordBrokerFactory'], 'auth.password.broker' => ['Illuminate\\Auth\\Passwords\\PasswordBroker', 'Illuminate\\Contracts\\Auth\\PasswordBroker'], 'queue' => ['Illuminate\\Queue\\QueueManager', 'Illuminate\\Contracts\\Queue\\Factory', 'Illuminate\\Contracts\\Queue\\Monitor'], 'queue.connection' => ['Illuminate\\Contracts\\Queue\\Queue'], 'queue.failer' => ['Illuminate\\Queue\\Failed\\FailedJobProviderInterface'], 'redirect' => ['Illuminate\\Routing\\Redirector'], 'redis' => ['Illuminate\\Redis\\Database', 'Illuminate\\Contracts\\Redis\\Database'], 'request' => ['Illuminate\\Http\\Request', 'Symfony\\Component\\HttpFoundation\\Request'], 'router' => ['Illuminate\\Routing\\Router', 'Illuminate\\Contracts\\Routing\\Registrar'], 'session' => ['Illuminate\\Session\\SessionManager'], 'session.store' => ['Illuminate\\Session\\Store', 'Symfony\\Component\\HttpFoundation\\Session\\SessionInterface'], 'url' => ['Illuminate\\Routing\\UrlGenerator', 'Illuminate\\Contracts\\Routing\\UrlGenerator'], 'validator' => ['Illuminate\\Validation\\Factory', 'Illuminate\\Contracts\\Validation\\Factory'], 'view' => ['Illuminate\\View\\Factory', 'Illuminate\\Contracts\\View\\Factory']];
foreach ($aliases as $key => $aliases) {
foreach ($aliases as $alias) {
$this->alias($key, $alias);
}
}
}
public function flush()
{
parent::flush();
$this->loadedProviders = [];
}
public function getNamespace()
{
if (!is_null($this->namespace)) {
return $this->namespace;
}
$composer = json_decode(file_get_contents(base_path('composer.json')), true);
foreach ((array) data_get($composer, 'autoload.psr-4') as $namespace => $path) {
foreach ((array) $path as $pathChoice) {
if (realpath(app_path()) == realpath(base_path() . '/' . $pathChoice)) {
return $this->namespace = $namespace;
}
}
}
throw new RuntimeException('Unable to detect application namespace.');
}
}
}
namespace Illuminate\Foundation {
use Closure;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
class EnvironmentDetector
{
public function detect(Closure $callback, $consoleArgs = null)
{
if ($consoleArgs) {
return $this->detectConsoleEnvironment($callback, $consoleArgs);
}
return $this->detectWebEnvironment($callback);
}
protected function detectWebEnvironment(Closure $callback)
{
return call_user_func($callback);
}
protected function detectConsoleEnvironment(Closure $callback, array $args)
{
if (!is_null($value = $this->getEnvironmentArgument($args))) {
return head(array_slice(explode('=', $value), 1));
}
return $this->detectWebEnvironment($callback);
}
protected function getEnvironmentArgument(array $args)
{
return Arr::first($args, function ($k, $v) {
return Str::startsWith($v, '--env');
});
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Illuminate\Log\Writer;
use Monolog\Logger as Monolog;
use Illuminate\Contracts\Foundation\Application;
class ConfigureLogging
{
public function bootstrap(Application $app)
{
$log = $this->registerLogger($app);
if ($app->hasMonologConfigurator()) {
call_user_func($app->getMonologConfigurator(), $log->getMonolog());
} else {
$this->configureHandlers($app, $log);
}
}
protected function registerLogger(Application $app)
{
$app->instance('log', $log = new Writer(new Monolog($app->environment()), $app['events']));
return $log;
}
protected function configureHandlers(Application $app, Writer $log)
{
$method = 'configure' . ucfirst($app['config']['app.log']) . 'Handler';
$this->{$method}($app, $log);
}
protected function configureSingleHandler(Application $app, Writer $log)
{
$log->useFiles($app->storagePath() . '/logs/laravel.log', $app->make('config')->get('app.log_level', 'debug'));
}
protected function configureDailyHandler(Application $app, Writer $log)
{
$config = $app->make('config');
$maxFiles = $config->get('app.log_max_files');
$log->useDailyFiles($app->storagePath() . '/logs/laravel.log', is_null($maxFiles) ? 5 : $maxFiles, $config->get('app.log_level', 'debug'));
}
protected function configureSyslogHandler(Application $app, Writer $log)
{
$log->useSyslog('laravel', $app->make('config')->get('app.log_level', 'debug'));
}
protected function configureErrorlogHandler(Application $app, Writer $log)
{
$log->useErrorLog($app->make('config')->get('app.log_level', 'debug'));
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Exception;
use ErrorException;
use Illuminate\Contracts\Foundation\Application;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Debug\Exception\FatalErrorException;
use Symfony\Component\Debug\Exception\FatalThrowableError;
class HandleExceptions
{
protected $app;
public function bootstrap(Application $app)
{
$this->app = $app;
error_reporting(-1);
set_error_handler([$this, 'handleError']);
set_exception_handler([$this, 'handleException']);
register_shutdown_function([$this, 'handleShutdown']);
if (!$app->environment('testing')) {
ini_set('display_errors', 'Off');
}
}
public function handleError($level, $message, $file = '', $line = 0, $context = [])
{
if (error_reporting() & $level) {
throw new ErrorException($message, 0, $level, $file, $line);
}
}
public function handleException($e)
{
if (!$e instanceof Exception) {
$e = new FatalThrowableError($e);
}
$this->getExceptionHandler()->report($e);
if ($this->app->runningInConsole()) {
$this->renderForConsole($e);
} else {
$this->renderHttpResponse($e);
}
}
protected function renderForConsole(Exception $e)
{
$this->getExceptionHandler()->renderForConsole(new ConsoleOutput(), $e);
}
protected function renderHttpResponse(Exception $e)
{
$this->getExceptionHandler()->render($this->app['request'], $e)->send();
}
public function handleShutdown()
{
if (!is_null($error = error_get_last()) && $this->isFatal($error['type'])) {
$this->handleException($this->fatalExceptionFromError($error, 0));
}
}
protected function fatalExceptionFromError(array $error, $traceOffset = null)
{
return new FatalErrorException($error['message'], $error['type'], 0, $error['file'], $error['line'], $traceOffset);
}
protected function isFatal($type)
{
return in_array($type, [E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_PARSE]);
}
protected function getExceptionHandler()
{
return $this->app->make('Illuminate\\Contracts\\Debug\\ExceptionHandler');
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Illuminate\Support\Facades\Facade;
use Illuminate\Foundation\AliasLoader;
use Illuminate\Contracts\Foundation\Application;
class RegisterFacades
{
public function bootstrap(Application $app)
{
Facade::clearResolvedInstances();
Facade::setFacadeApplication($app);
AliasLoader::getInstance($app->make('config')->get('app.aliases'))->register();
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Illuminate\Contracts\Foundation\Application;
class RegisterProviders
{
public function bootstrap(Application $app)
{
$app->registerConfiguredProviders();
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Illuminate\Contracts\Foundation\Application;
class BootProviders
{
public function bootstrap(Application $app)
{
$app->boot();
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Illuminate\Config\Repository;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Config\Repository as RepositoryContract;
class LoadConfiguration
{
public function bootstrap(Application $app)
{
$items = [];
if (file_exists($cached = $app->getCachedConfigPath())) {
$items = (require $cached);
$loadedFromCache = true;
}
$app->instance('config', $config = new Repository($items));
if (!isset($loadedFromCache)) {
$this->loadConfigurationFiles($app, $config);
}
$app->detectEnvironment(function () use($config) {
return $config->get('app.env', 'production');
});
date_default_timezone_set($config['app.timezone']);
mb_internal_encoding('UTF-8');
}
protected function loadConfigurationFiles(Application $app, RepositoryContract $repository)
{
foreach ($this->getConfigurationFiles($app) as $key => $path) {
$repository->set($key, require $path);
}
}
protected function getConfigurationFiles(Application $app)
{
$files = [];
$configPath = realpath($app->configPath());
foreach (Finder::create()->files()->name('*.php')->in($configPath) as $file) {
$nesting = $this->getConfigurationNesting($file, $configPath);
$files[$nesting . basename($file->getRealPath(), '.php')] = $file->getRealPath();
}
return $files;
}
protected function getConfigurationNesting(SplFileInfo $file, $configPath)
{
$directory = dirname($file->getRealPath());
if ($tree = trim(str_replace($configPath, '', $directory), DIRECTORY_SEPARATOR)) {
$tree = str_replace(DIRECTORY_SEPARATOR, '.', $tree) . '.';
}
return $tree;
}
}
}
namespace Illuminate\Foundation\Bootstrap {
use Dotenv\Dotenv;
use Dotenv\Exception\InvalidPathException;
use Illuminate\Contracts\Foundation\Application;
class DetectEnvironment
{
public function bootstrap(Application $app)
{
if (!$app->configurationIsCached()) {
$this->checkForSpecificEnvironmentFile($app);
try {
(new Dotenv($app->environmentPath(), $app->environmentFile()))->load();
} catch (InvalidPathException $e) {
}
}
}
protected function checkForSpecificEnvironmentFile($app)
{
if (!env('APP_ENV')) {
return;
}
$file = $app->environmentFile() . '.' . env('APP_ENV');
if (file_exists($app->environmentPath() . '/' . $file)) {
$app->loadEnvironmentFrom($file);
}
}
}
}
namespace Illuminate\Foundation\Http {
use Exception;
use Throwable;
use Illuminate\Routing\Router;
use Illuminate\Routing\Pipeline;
use Illuminate\Support\Facades\Facade;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Debug\ExceptionHandler;
use Illuminate\Contracts\Http\Kernel as KernelContract;
use Symfony\Component\Debug\Exception\FatalThrowableError;
class Kernel implements KernelContract
{
protected $app;
protected $router;
protected $bootstrappers = ['Illuminate\\Foundation\\Bootstrap\\DetectEnvironment', 'Illuminate\\Foundation\\Bootstrap\\LoadConfiguration', 'Illuminate\\Foundation\\Bootstrap\\ConfigureLogging', 'Illuminate\\Foundation\\Bootstrap\\HandleExceptions', 'Illuminate\\Foundation\\Bootstrap\\RegisterFacades', 'Illuminate\\Foundation\\Bootstrap\\RegisterProviders', 'Illuminate\\Foundation\\Bootstrap\\BootProviders'];
protected $middleware = [];
protected $middlewareGroups = [];
protected $routeMiddleware = [];
public function __construct(Application $app, Router $router)
{
$this->app = $app;
$this->router = $router;
foreach ($this->middlewareGroups as $key => $middleware) {
$router->middlewareGroup($key, $middleware);
}
foreach ($this->routeMiddleware as $key => $middleware) {
$router->middleware($key, $middleware);
}
}
public function handle($request)
{
try {
$request->enableHttpMethodParameterOverride();
$response = $this->sendRequestThroughRouter($request);
} catch (Exception $e) {
$this->reportException($e);
$response = $this->renderException($request, $e);
} catch (Throwable $e) {
$this->reportException($e = new FatalThrowableError($e));
$response = $this->renderException($request, $e);
}
$this->app['events']->fire('kernel.handled', [$request, $response]);
return $response;
}
protected function sendRequestThroughRouter($request)
{
$this->app->instance('request', $request);
Facade::clearResolvedInstance('request');
$this->bootstrap();
return (new Pipeline($this->app))->send($request)->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)->then($this->dispatchToRouter());
}
public function terminate($request, $response)
{
$middlewares = $this->app->shouldSkipMiddleware() ? [] : array_merge($this->gatherRouteMiddlewares($request), $this->middleware);
foreach ($middlewares as $middleware) {
list($name, $parameters) = $this->parseMiddleware($middleware);
$instance = $this->app->make($name);
if (method_exists($instance, 'terminate')) {
$instance->terminate($request, $response);
}
}
$this->app->terminate();
}
protected function gatherRouteMiddlewares($request)
{
if ($route = $request->route()) {
return $this->router->gatherRouteMiddlewares($route);
}
return [];
}
protected function parseMiddleware($middleware)
{
list($name, $parameters) = array_pad(explode(':', $middleware, 2), 2, []);
if (is_string($parameters)) {
$parameters = explode(',', $parameters);
}
return [$name, $parameters];
}
public function prependMiddleware($middleware)
{
if (array_search($middleware, $this->middleware) === false) {
array_unshift($this->middleware, $middleware);
}
return $this;
}
public function pushMiddleware($middleware)
{
if (array_search($middleware, $this->middleware) === false) {
$this->middleware[] = $middleware;
}
return $this;
}
public function bootstrap()
{
if (!$this->app->hasBeenBootstrapped()) {
$this->app->bootstrapWith($this->bootstrappers());
}
}
protected function dispatchToRouter()
{
return function ($request) {
$this->app->instance('request', $request);
return $this->router->dispatch($request);
};
}
public function hasMiddleware($middleware)
{
return in_array($middleware, $this->middleware);
}
protected function bootstrappers()
{
return $this->bootstrappers;
}
protected function reportException(Exception $e)
{
$this->app[ExceptionHandler::class]->report($e);
}
protected function renderException($request, Exception $e)
{
return $this->app[ExceptionHandler::class]->render($request, $e);
}
public function getApplication()
{
return $this->app;
}
}
}
namespace Illuminate\Foundation\Auth {
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Lang;
trait AuthenticatesUsers
{
use RedirectsUsers;
public function getLogin()
{
return $this->showLoginForm();
}
public function showLoginForm()
{
$view = property_exists($this, 'loginView') ? $this->loginView : 'auth.authenticate';
if (view()->exists($view)) {
return view($view);
}
return view('auth.login');
}
public function postLogin(Request $request)
{
return $this->login($request);
}
public function login(Request $request)
{
$this->validateLogin($request);
$throttles = $this->isUsingThrottlesLoginsTrait();
if ($throttles && ($lockedOut = $this->hasTooManyLoginAttempts($request))) {
$this->fireLockoutEvent($request);
return $this->sendLockoutResponse($request);
}
$credentials = $this->getCredentials($request);
if (Auth::guard($this->getGuard())->attempt($credentials, $request->has('remember'))) {
return $this->handleUserWasAuthenticated($request, $throttles);
}
if ($throttles && !$lockedOut) {
$this->incrementLoginAttempts($request);
}
return $this->sendFailedLoginResponse($request);
}
protected function validateLogin(Request $request)
{
$this->validate($request, [$this->loginUsername() => 'required', 'password' => 'required']);
}
protected function handleUserWasAuthenticated(Request $request, $throttles)
{
if ($throttles) {
$this->clearLoginAttempts($request);
}
if (method_exists($this, 'authenticated')) {
return $this->authenticated($request, Auth::guard($this->getGuard())->user());
}
return redirect()->intended($this->redirectPath());
}
protected function sendFailedLoginResponse(Request $request)
{
return redirect()->back()->withInput($request->only($this->loginUsername(), 'remember'))->withErrors([$this->loginUsername() => $this->getFailedLoginMessage()]);
}
protected function getFailedLoginMessage()
{
return Lang::has('auth.failed') ? Lang::get('auth.failed') : 'These credentials do not match our records.';
}
protected function getCredentials(Request $request)
{
return $request->only($this->loginUsername(), 'password');
}
public function getLogout()
{
return $this->logout();
}
public function logout()
{
Auth::guard($this->getGuard())->logout();
return redirect(property_exists($this, 'redirectAfterLogout') ? $this->redirectAfterLogout : '/');
}
public function guestMiddleware()
{
$guard = $this->getGuard();
return $guard ? 'guest:' . $guard : 'guest';
}
public function loginUsername()
{
return property_exists($this, 'username') ? $this->username : 'email';
}
protected function isUsingThrottlesLoginsTrait()
{
return in_array(ThrottlesLogins::class, class_uses_recursive(static::class));
}
protected function getGuard()
{
return property_exists($this, 'guard') ? $this->guard : null;
}
}
}
namespace Illuminate\Foundation\Auth {
trait RedirectsUsers
{
public function redirectPath()
{
if (property_exists($this, 'redirectPath')) {
return $this->redirectPath;
}
return property_exists($this, 'redirectTo') ? $this->redirectTo : '/home';
}
}
}
namespace Illuminate\Foundation\Auth {
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
trait RegistersUsers
{
use RedirectsUsers;
public function getRegister()
{
return $this->showRegistrationForm();
}
public function showRegistrationForm()
{
if (property_exists($this, 'registerView')) {
return view($this->registerView);
}
return view('auth.register');
}
public function postRegister(Request $request)
{
return $this->register($request);
}
public function register(Request $request)
{
$validator = $this->validator($request->all());
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
Auth::guard($this->getGuard())->login($this->create($request->all()));
return redirect($this->redirectPath());
}
protected function getGuard()
{
return property_exists($this, 'guard') ? $this->guard : null;
}
}
}
namespace Illuminate\Foundation\Auth {
use Illuminate\Support\Str;
use Illuminate\Http\Request;
use Illuminate\Mail\Message;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Password;
trait ResetsPasswords
{
use RedirectsUsers;
protected function guestMiddleware()
{
$guard = $this->getGuard();
return $guard ? 'guest:' . $guard : 'guest';
}
public function getEmail()
{
return $this->showLinkRequestForm();
}
public function showLinkRequestForm()
{
if (property_exists($this, 'linkRequestView')) {
return view($this->linkRequestView);
}
if (view()->exists('auth.passwords.email')) {
return view('auth.passwords.email');
}
return view('auth.password');
}
public function postEmail(Request $request)
{
return $this->sendResetLinkEmail($request);
}
public function sendResetLinkEmail(Request $request)
{
$this->validateSendResetLinkEmail($request);
$broker = $this->getBroker();
$response = Password::broker($broker)->sendResetLink($this->getSendResetLinkEmailCredentials($request), $this->resetEmailBuilder());
switch ($response) {
case Password::RESET_LINK_SENT:
return $this->getSendResetLinkEmailSuccessResponse($response);
case Password::INVALID_USER:
default:
return $this->getSendResetLinkEmailFailureResponse($response);
}
}
protected function validateSendResetLinkEmail(Request $request)
{
$this->validate($request, ['email' => 'required|email']);
}
protected function getSendResetLinkEmailCredentials(Request $request)
{
return $request->only('email');
}
protected function resetEmailBuilder()
{
return function (Message $message) {
$message->subject($this->getEmailSubject());
};
}
protected function getEmailSubject()
{
return property_exists($this, 'subject') ? $this->subject : 'Your Password Reset Link';
}
protected function getSendResetLinkEmailSuccessResponse($response)
{
return redirect()->back()->with('status', trans($response));
}
protected function getSendResetLinkEmailFailureResponse($response)
{
return redirect()->back()->withErrors(['email' => trans($response)]);
}
public function getReset(Request $request, $token = null)
{
return $this->showResetForm($request, $token);
}
public function showResetForm(Request $request, $token = null)
{
if (is_null($token)) {
return $this->getEmail();
}
$email = $request->input('email');
if (property_exists($this, 'resetView')) {
return view($this->resetView)->with(compact('token', 'email'));
}
if (view()->exists('auth.passwords.reset')) {
return view('auth.passwords.reset')->with(compact('token', 'email'));
}
return view('auth.reset')->with(compact('token', 'email'));
}
public function postReset(Request $request)
{
return $this->reset($request);
}
public function reset(Request $request)
{
$this->validate($request, $this->getResetValidationRules(), $this->getResetValidationMessages(), $this->getResetValidationCustomAttributes());
$credentials = $this->getResetCredentials($request);
$broker = $this->getBroker();
$response = Password::broker($broker)->reset($credentials, function ($user, $password) {
$this->resetPassword($user, $password);
});
switch ($response) {
case Password::PASSWORD_RESET:
return $this->getResetSuccessResponse($response);
default:
return $this->getResetFailureResponse($request, $response);
}
}
protected function getResetValidationRules()
{
return ['token' => 'required', 'email' => 'required|email', 'password' => 'required|confirmed|min:6'];
}
protected function getResetValidationMessages()
{
return [];
}
protected function getResetValidationCustomAttributes()
{
return [];
}
protected function getResetCredentials(Request $request)
{
return $request->only('email', 'password', 'password_confirmation', 'token');
}
protected function resetPassword($user, $password)
{
$user->forceFill(['password' => bcrypt($password), 'remember_token' => Str::random(60)])->save();
Auth::guard($this->getGuard())->login($user);
}
protected function getResetSuccessResponse($response)
{
return redirect($this->redirectPath())->with('status', trans($response));
}
protected function getResetFailureResponse(Request $request, $response)
{
return redirect()->back()->withInput($request->only('email'))->withErrors(['email' => trans($response)]);
}
public function getBroker()
{
return property_exists($this, 'broker') ? $this->broker : null;
}
protected function getGuard()
{
return property_exists($this, 'guard') ? $this->guard : null;
}
}
}
namespace Illuminate\Http {
use Closure;
use ArrayAccess;
use SplFileInfo;
use RuntimeException;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Macroable;
use Illuminate\Contracts\Support\Arrayable;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
class Request extends SymfonyRequest implements Arrayable, ArrayAccess
{
use Macroable;
protected $json;
protected $convertedFiles;
protected $userResolver;
protected $routeResolver;
public static function capture()
{
static::enableHttpMethodParameterOverride();
return static::createFromBase(SymfonyRequest::createFromGlobals());
}
public function instance()
{
return $this;
}
public function method()
{
return $this->getMethod();
}
public function root()
{
return rtrim($this->getSchemeAndHttpHost() . $this->getBaseUrl(), '/');
}
public function url()
{
return rtrim(preg_replace('/\\?.*/', '', $this->getUri()), '/');
}
public function fullUrl()
{
$query = $this->getQueryString();
$question = $this->getBaseUrl() . $this->getPathInfo() == '/' ? '/?' : '?';
return $query ? $this->url() . $question . $query : $this->url();
}
public function fullUrlWithQuery(array $query)
{
return count($this->query()) > 0 ? $this->url() . '/?' . http_build_query(array_merge($this->query(), $query)) : $this->fullUrl() . '?' . http_build_query($query);
}
public function path()
{
$pattern = trim($this->getPathInfo(), '/');
return $pattern == '' ? '/' : $pattern;
}
public function decodedPath()
{
return rawurldecode($this->path());
}
public function segment($index, $default = null)
{
return Arr::get($this->segments(), $index - 1, $default);
}
public function segments()
{
$segments = explode('/', $this->path());
return array_values(array_filter($segments, function ($v) {
return $v != '';
}));
}
public function is()
{
foreach (func_get_args() as $pattern) {
if (Str::is($pattern, urldecode($this->path()))) {
return true;
}
}
return false;
}
public function fullUrlIs()
{
$url = $this->fullUrl();
foreach (func_get_args() as $pattern) {
if (Str::is($pattern, $url)) {
return true;
}
}
return false;
}
public function ajax()
{
return $this->isXmlHttpRequest();
}
public function pjax()
{
return $this->headers->get('X-PJAX') == true;
}
public function secure()
{
return $this->isSecure();
}
public function ip()
{
return $this->getClientIp();
}
public function ips()
{
return $this->getClientIps();
}
public function exists($key)
{
$keys = is_array($key) ? $key : func_get_args();
$input = $this->all();
foreach ($keys as $value) {
if (!Arr::has($input, $value)) {
return false;
}
}
return true;
}
public function has($key)
{
$keys = is_array($key) ? $key : func_get_args();
foreach ($keys as $value) {
if ($this->isEmptyString($value)) {
return false;
}
}
return true;
}
protected function isEmptyString($key)
{
$value = $this->input($key);
$boolOrArray = is_bool($value) || is_array($value);
return !$boolOrArray && trim((string) $value) === '';
}
public function all()
{
return array_replace_recursive($this->input(), $this->allFiles());
}
public function input($key = null, $default = null)
{
$input = $this->getInputSource()->all() + $this->query->all();
return data_get($input, $key, $default);
}
public function only($keys)
{
$keys = is_array($keys) ? $keys : func_get_args();
$results = [];
$input = $this->all();
foreach ($keys as $key) {
Arr::set($results, $key, data_get($input, $key));
}
return $results;
}
public function except($keys)
{
$keys = is_array($keys) ? $keys : func_get_args();
$results = $this->all();
Arr::forget($results, $keys);
return $results;
}
public function intersect($keys)
{
return array_filter($this->only(is_array($keys) ? $keys : func_get_args()));
}
public function query($key = null, $default = null)
{
return $this->retrieveItem('query', $key, $default);
}
public function hasCookie($key)
{
return !is_null($this->cookie($key));
}
public function cookie($key = null, $default = null)
{
return $this->retrieveItem('cookies', $key, $default);
}
public function allFiles()
{
$files = $this->files->all();
return $this->convertedFiles ? $this->convertedFiles : ($this->convertedFiles = $this->convertUploadedFiles($files));
}
protected function convertUploadedFiles(array $files)
{
return array_map(function ($file) {
if (is_null($file) || is_array($file) && empty(array_filter($file))) {
return $file;
}
return is_array($file) ? $this->convertUploadedFiles($file) : UploadedFile::createFromBase($file);
}, $files);
}
public function file($key = null, $default = null)
{
return data_get($this->allFiles(), $key, $default);
}
public function hasFile($key)
{
if (!is_array($files = $this->file($key))) {
$files = [$files];
}
foreach ($files as $file) {
if ($this->isValidFile($file)) {
return true;
}
}
return false;
}
protected function isValidFile($file)
{
return $file instanceof SplFileInfo && $file->getPath() != '';
}
public function hasHeader($key)
{
return !is_null($this->header($key));
}
public function header($key = null, $default = null)
{
return $this->retrieveItem('headers', $key, $default);
}
public function server($key = null, $default = null)
{
return $this->retrieveItem('server', $key, $default);
}
public function old($key = null, $default = null)
{
return $this->session()->getOldInput($key, $default);
}
public function flash($filter = null, $keys = [])
{
$flash = !is_null($filter) ? $this->{$filter}($keys) : $this->input();
$this->session()->flashInput($flash);
}
public function flashOnly($keys)
{
$keys = is_array($keys) ? $keys : func_get_args();
return $this->flash('only', $keys);
}
public function flashExcept($keys)
{
$keys = is_array($keys) ? $keys : func_get_args();
return $this->flash('except', $keys);
}
public function flush()
{
$this->session()->flashInput([]);
}
protected function retrieveItem($source, $key, $default)
{
if (is_null($key)) {
return $this->{$source}->all();
}
return $this->{$source}->get($key, $default);
}
public function merge(array $input)
{
$this->getInputSource()->add($input);
}
public function replace(array $input)
{
$this->getInputSource()->replace($input);
}
public function json($key = null, $default = null)
{
if (!isset($this->json)) {
$this->json = new ParameterBag((array) json_decode($this->getContent(), true));
}
if (is_null($key)) {
return $this->json;
}
return data_get($this->json->all(), $key, $default);
}
protected function getInputSource()
{
if ($this->isJson()) {
return $this->json();
}
return $this->getMethod() == 'GET' ? $this->query : $this->request;
}
public static function matchesType($actual, $type)
{
if ($actual === $type) {
return true;
}
$split = explode('/', $actual);
return isset($split[1]) && preg_match('#' . preg_quote($split[0], '#') . '/.+\\+' . preg_quote($split[1], '#') . '#', $type);
}
public function isJson()
{
return Str::contains($this->header('CONTENT_TYPE'), ['/json', '+json']);
}
public function wantsJson()
{
$acceptable = $this->getAcceptableContentTypes();
return isset($acceptable[0]) && Str::contains($acceptable[0], ['/json', '+json']);
}
public function accepts($contentTypes)
{
$accepts = $this->getAcceptableContentTypes();
if (count($accepts) === 0) {
return true;
}
$types = (array) $contentTypes;
foreach ($accepts as $accept) {
if ($accept === '*/*' || $accept === '*') {
return true;
}
foreach ($types as $type) {
if ($this->matchesType($accept, $type) || $accept === strtok($type, '/') . '/*') {
return true;
}
}
}
return false;
}
public function prefers($contentTypes)
{
$accepts = $this->getAcceptableContentTypes();
$contentTypes = (array) $contentTypes;
foreach ($accepts as $accept) {
if (in_array($accept, ['*/*', '*'])) {
return $contentTypes[0];
}
foreach ($contentTypes as $contentType) {
$type = $contentType;
if (!is_null($mimeType = $this->getMimeType($contentType))) {
$type = $mimeType;
}
if ($this->matchesType($type, $accept) || $accept === strtok($type, '/') . '/*') {
return $contentType;
}
}
}
}
public function acceptsJson()
{
return $this->accepts('application/json');
}
public function acceptsHtml()
{
return $this->accepts('text/html');
}
public function format($default = 'html')
{
foreach ($this->getAcceptableContentTypes() as $type) {
if ($format = $this->getFormat($type)) {
return $format;
}
}
return $default;
}
public function bearerToken()
{
$header = $this->header('Authorization', '');
if (Str::startsWith($header, 'Bearer ')) {
return Str::substr($header, 7);
}
}
public static function createFromBase(SymfonyRequest $request)
{
if ($request instanceof static) {
return $request;
}
$content = $request->content;
$request = (new static())->duplicate($request->query->all(), $request->request->all(), $request->attributes->all(), $request->cookies->all(), $request->files->all(), $request->server->all());
$request->content = $content;
$request->request = $request->getInputSource();
return $request;
}
public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
{
return parent::duplicate($query, $request, $attributes, $cookies, array_filter((array) $files), $server);
}
public function session()
{
if (!$this->hasSession()) {
throw new RuntimeException('Session store not set on request.');
}
return $this->getSession();
}
public function user($guard = null)
{
return call_user_func($this->getUserResolver(), $guard);
}
public function route($param = null)
{
$route = call_user_func($this->getRouteResolver());
if (is_null($route) || is_null($param)) {
return $route;
} else {
return $route->parameter($param);
}
}
public function fingerprint()
{
if (!$this->route()) {
throw new RuntimeException('Unable to generate fingerprint. Route unavailable.');
}
return sha1(implode('|', $this->route()->methods()) . '|' . $this->route()->domain() . '|' . $this->route()->uri() . '|' . $this->ip());
}
public function getUserResolver()
{
return $this->userResolver ?: function () {
};
}
public function setUserResolver(Closure $callback)
{
$this->userResolver = $callback;
return $this;
}
public function getRouteResolver()
{
return $this->routeResolver ?: function () {
};
}
public function setRouteResolver(Closure $callback)
{
$this->routeResolver = $callback;
return $this;
}
public function toArray()
{
return $this->all();
}
public function offsetExists($offset)
{
return array_key_exists($offset, $this->all());
}
public function offsetGet($offset)
{
return data_get($this->all(), $offset);
}
public function offsetSet($offset, $value)
{
return $this->getInputSource()->set($offset, $value);
}
public function offsetUnset($offset)
{
return $this->getInputSource()->remove($offset);
}
public function __isset($key)
{
return !is_null($this->__get($key));
}
public function __get($key)
{
$all = $this->all();
if (array_key_exists($key, $all)) {
return $all[$key];
} else {
return $this->route($key);
}
}
}
}
namespace Illuminate\Http\Middleware {
use Closure;
class FrameGuard
{
public function handle($request, Closure $next)
{
$response = $next($request);
$response->headers->set('X-Frame-Options', 'SAMEORIGIN', false);
return $response;
}
}
}
namespace Illuminate\Foundation\Http\Middleware {
use Closure;
use Illuminate\Foundation\Application;
use Symfony\Component\HttpFoundation\Cookie;
use Illuminate\Contracts\Encryption\Encrypter;
use Illuminate\Session\TokenMismatchException;
class VerifyCsrfToken
{
protected $app;
protected $encrypter;
protected $except = [];
public function __construct(Application $app, Encrypter $encrypter)
{
$this->app = $app;
$this->encrypter = $encrypter;
}
public function handle($request, Closure $next)
{
if ($this->isReading($request) || $this->runningUnitTests() || $this->shouldPassThrough($request) || $this->tokensMatch($request)) {
return $this->addCookieToResponse($request, $next($request));
}
throw new TokenMismatchException();
}
protected function shouldPassThrough($request)
{
foreach ($this->except as $except) {
if ($except !== '/') {
$except = trim($except, '/');
}
if ($request->is($except)) {
return true;
}
}
return false;
}
protected function runningUnitTests()
{
return $this->app->runningInConsole() && $this->app->runningUnitTests();
}
protected function tokensMatch($request)
{
$sessionToken = $request->session()->token();
$token = $request->input('_token') ?: $request->header('X-CSRF-TOKEN');
if (!$token && ($header = $request->header('X-XSRF-TOKEN'))) {
$token = $this->encrypter->decrypt($header);
}
if (!is_string($sessionToken) || !is_string($token)) {
return false;
}
return hash_equals($sessionToken, $token);
}
protected function addCookieToResponse($request, $response)
{
$config = config('session');
$response->headers->setCookie(new Cookie('XSRF-TOKEN', $request->session()->token(), time() + 60 * $config['lifetime'], $config['path'], $config['domain'], $config['secure'], false));
return $response;
}
protected function isReading($request)
{
return in_array($request->method(), ['HEAD', 'GET', 'OPTIONS']);
}
}
}
namespace Illuminate\Foundation\Http\Middleware {
use Closure;
use Illuminate\Contracts\Foundation\Application;
use Symfony\Component\HttpKernel\Exception\HttpException;
class CheckForMaintenanceMode
{
protected $app;
public function __construct(Application $app)
{
$this->app = $app;
}
public function handle($request, Closure $next)
{
if ($this->app->isDownForMaintenance()) {
throw new HttpException(503);
}
return $next($request);
}
}
}
namespace Symfony\Component\HttpFoundation {
use Symfony\Component\HttpFoundation\Exception\ConflictingHeadersException;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
class Request
{
const HEADER_FORWARDED = 'forwarded';
const HEADER_CLIENT_IP = 'client_ip';
const HEADER_CLIENT_HOST = 'client_host';
const HEADER_CLIENT_PROTO = 'client_proto';
const HEADER_CLIENT_PORT = 'client_port';
const METHOD_HEAD = 'HEAD';
const METHOD_GET = 'GET';
const METHOD_POST = 'POST';
const METHOD_PUT = 'PUT';
const METHOD_PATCH = 'PATCH';
const METHOD_DELETE = 'DELETE';
const METHOD_PURGE = 'PURGE';
const METHOD_OPTIONS = 'OPTIONS';
const METHOD_TRACE = 'TRACE';
const METHOD_CONNECT = 'CONNECT';
protected static $trustedProxies = array();
protected static $trustedHostPatterns = array();
protected static $trustedHosts = array();
protected static $trustedHeaders = array(self::HEADER_FORWARDED => 'FORWARDED', self::HEADER_CLIENT_IP => 'X_FORWARDED_FOR', self::HEADER_CLIENT_HOST => 'X_FORWARDED_HOST', self::HEADER_CLIENT_PROTO => 'X_FORWARDED_PROTO', self::HEADER_CLIENT_PORT => 'X_FORWARDED_PORT');
protected static $httpMethodParameterOverride = false;
public $attributes;
public $request;
public $query;
public $server;
public $files;
public $cookies;
public $headers;
protected $content;
protected $languages;
protected $charsets;
protected $encodings;
protected $acceptableContentTypes;
protected $pathInfo;
protected $requestUri;
protected $baseUrl;
protected $basePath;
protected $method;
protected $format;
protected $session;
protected $locale;
protected $defaultLocale = 'en';
protected static $formats;
protected static $requestFactory;
public function __construct(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
{
$this->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
}
public function initialize(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
{
$this->request = new ParameterBag($request);
$this->query = new ParameterBag($query);
$this->attributes = new ParameterBag($attributes);
$this->cookies = new ParameterBag($cookies);
$this->files = new FileBag($files);
$this->server = new ServerBag($server);
$this->headers = new HeaderBag($this->server->getHeaders());
$this->content = $content;
$this->languages = null;
$this->charsets = null;
$this->encodings = null;
$this->acceptableContentTypes = null;
$this->pathInfo = null;
$this->requestUri = null;
$this->baseUrl = null;
$this->basePath = null;
$this->method = null;
$this->format = null;
}
public static function createFromGlobals()
{
$server = $_SERVER;
if ('cli-server' === PHP_SAPI) {
if (array_key_exists('HTTP_CONTENT_LENGTH', $_SERVER)) {
$server['CONTENT_LENGTH'] = $_SERVER['HTTP_CONTENT_LENGTH'];
}
if (array_key_exists('HTTP_CONTENT_TYPE', $_SERVER)) {
$server['CONTENT_TYPE'] = $_SERVER['HTTP_CONTENT_TYPE'];
}
}
$request = self::createRequestFromFactory($_GET, $_POST, array(), $_COOKIE, $_FILES, $server);
if (0 === strpos($request->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded') && in_array(strtoupper($request->server->get('REQUEST_METHOD', 'GET')), array('PUT', 'DELETE', 'PATCH'))) {
parse_str($request->getContent(), $data);
$request->request = new ParameterBag($data);
}
return $request;
}
public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
{
$server = array_replace(array('SERVER_NAME' => 'localhost', 'SERVER_PORT' => 80, 'HTTP_HOST' => 'localhost', 'HTTP_USER_AGENT' => 'Symfony/3.X', 'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5', 'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', 'REMOTE_ADDR' => '127.0.0.1', 'SCRIPT_NAME' => '', 'SCRIPT_FILENAME' => '', 'SERVER_PROTOCOL' => 'HTTP/1.1', 'REQUEST_TIME' => time()), $server);
$server['PATH_INFO'] = '';
$server['REQUEST_METHOD'] = strtoupper($method);
$components = parse_url($uri);
if (isset($components['host'])) {
$server['SERVER_NAME'] = $components['host'];
$server['HTTP_HOST'] = $components['host'];
}
if (isset($components['scheme'])) {
if ('https' === $components['scheme']) {
$server['HTTPS'] = 'on';
$server['SERVER_PORT'] = 443;
} else {
unset($server['HTTPS']);
$server['SERVER_PORT'] = 80;
}
}
if (isset($components['port'])) {
$server['SERVER_PORT'] = $components['port'];
$server['HTTP_HOST'] = $server['HTTP_HOST'] . ':' . $components['port'];
}
if (isset($components['user'])) {
$server['PHP_AUTH_USER'] = $components['user'];
}
if (isset($components['pass'])) {
$server['PHP_AUTH_PW'] = $components['pass'];
}
if (!isset($components['path'])) {
$components['path'] = '/';
}
switch (strtoupper($method)) {
case 'POST':
case 'PUT':
case 'DELETE':
if (!isset($server['CONTENT_TYPE'])) {
$server['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
}
case 'PATCH':
$request = $parameters;
$query = array();
break;
default:
$request = array();
$query = $parameters;
break;
}
$queryString = '';
if (isset($components['query'])) {
parse_str(html_entity_decode($components['query']), $qs);
if ($query) {
$query = array_replace($qs, $query);
$queryString = http_build_query($query, '', '&');
} else {
$query = $qs;
$queryString = $components['query'];
}
} elseif ($query) {
$queryString = http_build_query($query, '', '&');
}
$server['REQUEST_URI'] = $components['path'] . ('' !== $queryString ? '?' . $queryString : '');
$server['QUERY_STRING'] = $queryString;
return self::createRequestFromFactory($query, $request, array(), $cookies, $files, $server, $content);
}
public static function setFactory($callable)
{
self::$requestFactory = $callable;
}
public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
{
$dup = clone $this;
if ($query !== null) {
$dup->query = new ParameterBag($query);
}
if ($request !== null) {
$dup->request = new ParameterBag($request);
}
if ($attributes !== null) {
$dup->attributes = new ParameterBag($attributes);
}
if ($cookies !== null) {
$dup->cookies = new ParameterBag($cookies);
}
if ($files !== null) {
$dup->files = new FileBag($files);
}
if ($server !== null) {
$dup->server = new ServerBag($server);
$dup->headers = new HeaderBag($dup->server->getHeaders());
}
$dup->languages = null;
$dup->charsets = null;
$dup->encodings = null;
$dup->acceptableContentTypes = null;
$dup->pathInfo = null;
$dup->requestUri = null;
$dup->baseUrl = null;
$dup->basePath = null;
$dup->method = null;
$dup->format = null;
if (!$dup->get('_format') && $this->get('_format')) {
$dup->attributes->set('_format', $this->get('_format'));
}
if (!$dup->getRequestFormat(null)) {
$dup->setRequestFormat($this->getRequestFormat(null));
}
return $dup;
}
public function __clone()
{
$this->query = clone $this->query;
$this->request = clone $this->request;
$this->attributes = clone $this->attributes;
$this->cookies = clone $this->cookies;
$this->files = clone $this->files;
$this->server = clone $this->server;
$this->headers = clone $this->headers;
}
public function __toString()
{
try {
$content = $this->getContent();
} catch (\LogicException $e) {
return trigger_error($e, E_USER_ERROR);
}
return sprintf('%s %s %s', $this->getMethod(), $this->getRequestUri(), $this->server->get('SERVER_PROTOCOL')) . "\r\n" . $this->headers . "\r\n" . $content;
}
public function overrideGlobals()
{
$this->server->set('QUERY_STRING', static::normalizeQueryString(http_build_query($this->query->all(), null, '&')));
$_GET = $this->query->all();
$_POST = $this->request->all();
$_SERVER = $this->server->all();
$_COOKIE = $this->cookies->all();
foreach ($this->headers->all() as $key => $value) {
$key = strtoupper(str_replace('-', '_', $key));
if (in_array($key, array('CONTENT_TYPE', 'CONTENT_LENGTH'))) {
$_SERVER[$key] = implode(', ', $value);
} else {
$_SERVER['HTTP_' . $key] = implode(', ', $value);
}
}
$request = array('g' => $_GET, 'p' => $_POST, 'c' => $_COOKIE);
$requestOrder = ini_get('request_order') ?: ini_get('variables_order');
$requestOrder = preg_replace('#[^cgp]#', '', strtolower($requestOrder)) ?: 'gp';
$_REQUEST = array();
foreach (str_split($requestOrder) as $order) {
$_REQUEST = array_merge($_REQUEST, $request[$order]);
}
}
public static function setTrustedProxies(array $proxies)
{
self::$trustedProxies = $proxies;
}
public static function getTrustedProxies()
{
return self::$trustedProxies;
}
public static function setTrustedHosts(array $hostPatterns)
{
self::$trustedHostPatterns = array_map(function ($hostPattern) {
return sprintf('#%s#i', $hostPattern);
}, $hostPatterns);
self::$trustedHosts = array();
}
public static function getTrustedHosts()
{
return self::$trustedHostPatterns;
}
public static function setTrustedHeaderName($key, $value)
{
if (!array_key_exists($key, self::$trustedHeaders)) {
throw new \InvalidArgumentException(sprintf('Unable to set the trusted header name for key "%s".', $key));
}
self::$trustedHeaders[$key] = $value;
}
public static function getTrustedHeaderName($key)
{
if (!array_key_exists($key, self::$trustedHeaders)) {
throw new \InvalidArgumentException(sprintf('Unable to get the trusted header name for key "%s".', $key));
}
return self::$trustedHeaders[$key];
}
public static function normalizeQueryString($qs)
{
if ('' == $qs) {
return '';
}
$parts = array();
$order = array();
foreach (explode('&', $qs) as $param) {
if ('' === $param || '=' === $param[0]) {
continue;
}
$keyValuePair = explode('=', $param, 2);
$parts[] = isset($keyValuePair[1]) ? rawurlencode(urldecode($keyValuePair[0])) . '=' . rawurlencode(urldecode($keyValuePair[1])) : rawurlencode(urldecode($keyValuePair[0]));
$order[] = urldecode($keyValuePair[0]);
}
array_multisort($order, SORT_ASC, $parts);
return implode('&', $parts);
}
public static function enableHttpMethodParameterOverride()
{
self::$httpMethodParameterOverride = true;
}
public static function getHttpMethodParameterOverride()
{
return self::$httpMethodParameterOverride;
}
public function get($key, $default = null)
{
if ($this !== ($result = $this->attributes->get($key, $this))) {
return $result;
}
if ($this !== ($result = $this->query->get($key, $this))) {
return $result;
}
if ($this !== ($result = $this->request->get($key, $this))) {
return $result;
}
return $default;
}
public function getSession()
{
return $this->session;
}
public function hasPreviousSession()
{
return $this->hasSession() && $this->cookies->has($this->session->getName());
}
public function hasSession()
{
return null !== $this->session;
}
public function setSession(SessionInterface $session)
{
$this->session = $session;
}
public function getClientIps()
{
$clientIps = array();
$ip = $this->server->get('REMOTE_ADDR');
if (!$this->isFromTrustedProxy()) {
return array($ip);
}
$hasTrustedForwardedHeader = self::$trustedHeaders[self::HEADER_FORWARDED] && $this->headers->has(self::$trustedHeaders[self::HEADER_FORWARDED]);
$hasTrustedClientIpHeader = self::$trustedHeaders[self::HEADER_CLIENT_IP] && $this->headers->has(self::$trustedHeaders[self::HEADER_CLIENT_IP]);
if ($hasTrustedForwardedHeader) {
$forwardedHeader = $this->headers->get(self::$trustedHeaders[self::HEADER_FORWARDED]);
preg_match_all('{(for)=("?\\[?)([a-z0-9\\.:_\\-/]*)}', $forwardedHeader, $matches);
$forwardedClientIps = $matches[3];
$forwardedClientIps = $this->normalizeAndFilterClientIps($forwardedClientIps, $ip);
$clientIps = $forwardedClientIps;
}
if ($hasTrustedClientIpHeader) {
$xForwardedForClientIps = array_map('trim', explode(',', $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_IP])));
$xForwardedForClientIps = $this->normalizeAndFilterClientIps($xForwardedForClientIps, $ip);
$clientIps = $xForwardedForClientIps;
}
if ($hasTrustedForwardedHeader && $hasTrustedClientIpHeader && $forwardedClientIps !== $xForwardedForClientIps) {
throw new ConflictingHeadersException('The request has both a trusted Forwarded header and a trusted Client IP header, conflicting with each other with regards to the originating IP addresses of the request. This is the result of a misconfiguration. You should either configure your proxy only to send one of these headers, or configure Symfony to distrust one of them.');
}
if (!$hasTrustedForwardedHeader && !$hasTrustedClientIpHeader) {
return $this->normalizeAndFilterClientIps(array(), $ip);
}
return $clientIps;
}
public function getClientIp()
{
$ipAddresses = $this->getClientIps();
return $ipAddresses[0];
}
public function getScriptName()
{
return $this->server->get('SCRIPT_NAME', $this->server->get('ORIG_SCRIPT_NAME', ''));
}
public function getPathInfo()
{
if (null === $this->pathInfo) {
$this->pathInfo = $this->preparePathInfo();
}
return $this->pathInfo;
}
public function getBasePath()
{
if (null === $this->basePath) {
$this->basePath = $this->prepareBasePath();
}
return $this->basePath;
}
public function getBaseUrl()
{
if (null === $this->baseUrl) {
$this->baseUrl = $this->prepareBaseUrl();
}
return $this->baseUrl;
}
public function getScheme()
{
return $this->isSecure() ? 'https' : 'http';
}
public function getPort()
{
if ($this->isFromTrustedProxy()) {
if (self::$trustedHeaders[self::HEADER_CLIENT_PORT] && ($port = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PORT]))) {
return $port;
}
if (self::$trustedHeaders[self::HEADER_CLIENT_PROTO] && 'https' === $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PROTO], 'http')) {
return 443;
}
}
if ($host = $this->headers->get('HOST')) {
if ($host[0] === '[') {
$pos = strpos($host, ':', strrpos($host, ']'));
} else {
$pos = strrpos($host, ':');
}
if (false !== $pos) {
return (int) substr($host, $pos + 1);
}
return 'https' === $this->getScheme() ? 443 : 80;
}
return $this->server->get('SERVER_PORT');
}
public function getUser()
{
return $this->headers->get('PHP_AUTH_USER');
}
public function getPassword()
{
return $this->headers->get('PHP_AUTH_PW');
}
public function getUserInfo()
{
$userinfo = $this->getUser();
$pass = $this->getPassword();
if ('' != $pass) {
$userinfo .= ":{$pass}";
}
return $userinfo;
}
public function getHttpHost()
{
$scheme = $this->getScheme();
$port = $this->getPort();
if ('http' == $scheme && $port == 80 || 'https' == $scheme && $port == 443) {
return $this->getHost();
}
return $this->getHost() . ':' . $port;
}
public function getRequestUri()
{
if (null === $this->requestUri) {
$this->requestUri = $this->prepareRequestUri();
}
return $this->requestUri;
}
public function getSchemeAndHttpHost()
{
return $this->getScheme() . '://' . $this->getHttpHost();
}
public function getUri()
{
if (null !== ($qs = $this->getQueryString())) {
$qs = '?' . $qs;
}
return $this->getSchemeAndHttpHost() . $this->getBaseUrl() . $this->getPathInfo() . $qs;
}
public function getUriForPath($path)
{
return $this->getSchemeAndHttpHost() . $this->getBaseUrl() . $path;
}
public function getRelativeUriForPath($path)
{
if (!isset($path[0]) || '/' !== $path[0]) {
return $path;
}
if ($path === ($basePath = $this->getPathInfo())) {
return '';
}
$sourceDirs = explode('/', isset($basePath[0]) && '/' === $basePath[0] ? substr($basePath, 1) : $basePath);
$targetDirs = explode('/', isset($path[0]) && '/' === $path[0] ? substr($path, 1) : $path);
array_pop($sourceDirs);
$targetFile = array_pop($targetDirs);
foreach ($sourceDirs as $i => $dir) {
if (isset($targetDirs[$i]) && $dir === $targetDirs[$i]) {
unset($sourceDirs[$i], $targetDirs[$i]);
} else {
break;
}
}
$targetDirs[] = $targetFile;
$path = str_repeat('../', count($sourceDirs)) . implode('/', $targetDirs);
return !isset($path[0]) || '/' === $path[0] || false !== ($colonPos = strpos($path, ':')) && ($colonPos < ($slashPos = strpos($path, '/')) || false === $slashPos) ? "./{$path}" : $path;
}
public function getQueryString()
{
$qs = static::normalizeQueryString($this->server->get('QUERY_STRING'));
return '' === $qs ? null : $qs;
}
public function isSecure()
{
if ($this->isFromTrustedProxy() && self::$trustedHeaders[self::HEADER_CLIENT_PROTO] && ($proto = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PROTO]))) {
return in_array(strtolower(current(explode(',', $proto))), array('https', 'on', 'ssl', '1'));
}
$https = $this->server->get('HTTPS');
return !empty($https) && 'off' !== strtolower($https);
}
public function getHost()
{
if ($this->isFromTrustedProxy() && self::$trustedHeaders[self::HEADER_CLIENT_HOST] && ($host = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_HOST]))) {
$elements = explode(',', $host);
$host = $elements[count($elements) - 1];
} elseif (!($host = $this->headers->get('HOST'))) {
if (!($host = $this->server->get('SERVER_NAME'))) {
$host = $this->server->get('SERVER_ADDR', '');
}
}
$host = strtolower(preg_replace('/:\\d+$/', '', trim($host)));
if ($host && '' !== preg_replace('/(?:^\\[)?[a-zA-Z0-9-:\\]_]+\\.?/', '', $host)) {
throw new \UnexpectedValueException(sprintf('Invalid Host "%s"', $host));
}
if (count(self::$trustedHostPatterns) > 0) {
if (in_array($host, self::$trustedHosts)) {
return $host;
}
foreach (self::$trustedHostPatterns as $pattern) {
if (preg_match($pattern, $host)) {
self::$trustedHosts[] = $host;
return $host;
}
}
throw new \UnexpectedValueException(sprintf('Untrusted Host "%s"', $host));
}
return $host;
}
public function setMethod($method)
{
$this->method = null;
$this->server->set('REQUEST_METHOD', $method);
}
public function getMethod()
{
if (null === $this->method) {
$this->method = strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
if ('POST' === $this->method) {
if ($method = $this->headers->get('X-HTTP-METHOD-OVERRIDE')) {
$this->method = strtoupper($method);
} elseif (self::$httpMethodParameterOverride) {
$this->method = strtoupper($this->request->get('_method', $this->query->get('_method', 'POST')));
}
}
}
return $this->method;
}
public function getRealMethod()
{
return strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
}
public function getMimeType($format)
{
if (null === static::$formats) {
static::initializeFormats();
}
return isset(static::$formats[$format]) ? static::$formats[$format][0] : null;
}
public function getFormat($mimeType)
{
$canonicalMimeType = null;
if (false !== ($pos = strpos($mimeType, ';'))) {
$canonicalMimeType = substr($mimeType, 0, $pos);
}
if (null === static::$formats) {
static::initializeFormats();
}
foreach (static::$formats as $format => $mimeTypes) {
if (in_array($mimeType, (array) $mimeTypes)) {
return $format;
}
if (null !== $canonicalMimeType && in_array($canonicalMimeType, (array) $mimeTypes)) {
return $format;
}
}
}
public function setFormat($format, $mimeTypes)
{
if (null === static::$formats) {
static::initializeFormats();
}
static::$formats[$format] = is_array($mimeTypes) ? $mimeTypes : array($mimeTypes);
}
public function getRequestFormat($default = 'html')
{
if (null === $this->format) {
$this->format = $this->attributes->get('_format', $default);
}
return $this->format;
}
public function setRequestFormat($format)
{
$this->format = $format;
}
public function getContentType()
{
return $this->getFormat($this->headers->get('CONTENT_TYPE'));
}
public function setDefaultLocale($locale)
{
$this->defaultLocale = $locale;
if (null === $this->locale) {
$this->setPhpDefaultLocale($locale);
}
}
public function getDefaultLocale()
{
return $this->defaultLocale;
}
public function setLocale($locale)
{
$this->setPhpDefaultLocale($this->locale = $locale);
}
public function getLocale()
{
return null === $this->locale ? $this->defaultLocale : $this->locale;
}
public function isMethod($method)
{
return $this->getMethod() === strtoupper($method);
}
public function isMethodSafe()
{
return in_array($this->getMethod(), array('GET', 'HEAD', 'OPTIONS', 'TRACE'));
}
public function getContent($asResource = false)
{
$currentContentIsResource = is_resource($this->content);
if (PHP_VERSION_ID < 50600 && false === $this->content) {
throw new \LogicException('getContent() can only be called once when using the resource return type and PHP below 5.6.');
}
if (true === $asResource) {
if ($currentContentIsResource) {
rewind($this->content);
return $this->content;
}
if (is_string($this->content)) {
$resource = fopen('php://temp', 'r+');
fwrite($resource, $this->content);
rewind($resource);
return $resource;
}
$this->content = false;
return fopen('php://input', 'rb');
}
if ($currentContentIsResource) {
rewind($this->content);
return stream_get_contents($this->content);
}
if (null === $this->content) {
$this->content = file_get_contents('php://input');
}
return $this->content;
}
public function getETags()
{
return preg_split('/\\s*,\\s*/', $this->headers->get('if_none_match'), null, PREG_SPLIT_NO_EMPTY);
}
public function isNoCache()
{
return $this->headers->hasCacheControlDirective('no-cache') || 'no-cache' == $this->headers->get('Pragma');
}
public function getPreferredLanguage(array $locales = null)
{
$preferredLanguages = $this->getLanguages();
if (empty($locales)) {
return isset($preferredLanguages[0]) ? $preferredLanguages[0] : null;
}
if (!$preferredLanguages) {
return $locales[0];
}
$extendedPreferredLanguages = array();
foreach ($preferredLanguages as $language) {
$extendedPreferredLanguages[] = $language;
if (false !== ($position = strpos($language, '_'))) {
$superLanguage = substr($language, 0, $position);
if (!in_array($superLanguage, $preferredLanguages)) {
$extendedPreferredLanguages[] = $superLanguage;
}
}
}
$preferredLanguages = array_values(array_intersect($extendedPreferredLanguages, $locales));
return isset($preferredLanguages[0]) ? $preferredLanguages[0] : $locales[0];
}
public function getLanguages()
{
if (null !== $this->languages) {
return $this->languages;
}
$languages = AcceptHeader::fromString($this->headers->get('Accept-Language'))->all();
$this->languages = array();
foreach ($languages as $lang => $acceptHeaderItem) {
if (false !== strpos($lang, '-')) {
$codes = explode('-', $lang);
if ('i' === $codes[0]) {
if (count($codes) > 1) {
$lang = $codes[1];
}
} else {
for ($i = 0, $max = count($codes); $i < $max; ++$i) {
if ($i === 0) {
$lang = strtolower($codes[0]);
} else {
$lang .= '_' . strtoupper($codes[$i]);
}
}
}
}
$this->languages[] = $lang;
}
return $this->languages;
}
public function getCharsets()
{
if (null !== $this->charsets) {
return $this->charsets;
}
return $this->charsets = array_keys(AcceptHeader::fromString($this->headers->get('Accept-Charset'))->all());
}
public function getEncodings()
{
if (null !== $this->encodings) {
return $this->encodings;
}
return $this->encodings = array_keys(AcceptHeader::fromString($this->headers->get('Accept-Encoding'))->all());
}
public function getAcceptableContentTypes()
{
if (null !== $this->acceptableContentTypes) {
return $this->acceptableContentTypes;
}
return $this->acceptableContentTypes = array_keys(AcceptHeader::fromString($this->headers->get('Accept'))->all());
}
public function isXmlHttpRequest()
{
return 'XMLHttpRequest' == $this->headers->get('X-Requested-With');
}
protected function prepareRequestUri()
{
$requestUri = '';
if ($this->headers->has('X_ORIGINAL_URL')) {
$requestUri = $this->headers->get('X_ORIGINAL_URL');
$this->headers->remove('X_ORIGINAL_URL');
$this->server->remove('HTTP_X_ORIGINAL_URL');
$this->server->remove('UNENCODED_URL');
$this->server->remove('IIS_WasUrlRewritten');
} elseif ($this->headers->has('X_REWRITE_URL')) {
$requestUri = $this->headers->get('X_REWRITE_URL');
$this->headers->remove('X_REWRITE_URL');
} elseif ($this->server->get('IIS_WasUrlRewritten') == '1' && $this->server->get('UNENCODED_URL') != '') {
$requestUri = $this->server->get('UNENCODED_URL');
$this->server->remove('UNENCODED_URL');
$this->server->remove('IIS_WasUrlRewritten');
} elseif ($this->server->has('REQUEST_URI')) {
$requestUri = $this->server->get('REQUEST_URI');
$schemeAndHttpHost = $this->getSchemeAndHttpHost();
if (strpos($requestUri, $schemeAndHttpHost) === 0) {
$requestUri = substr($requestUri, strlen($schemeAndHttpHost));
}
} elseif ($this->server->has('ORIG_PATH_INFO')) {
$requestUri = $this->server->get('ORIG_PATH_INFO');
if ('' != $this->server->get('QUERY_STRING')) {
$requestUri .= '?' . $this->server->get('QUERY_STRING');
}
$this->server->remove('ORIG_PATH_INFO');
}
$this->server->set('REQUEST_URI', $requestUri);
return $requestUri;
}
protected function prepareBaseUrl()
{
$filename = basename($this->server->get('SCRIPT_FILENAME'));
if (basename($this->server->get('SCRIPT_NAME')) === $filename) {
$baseUrl = $this->server->get('SCRIPT_NAME');
} elseif (basename($this->server->get('PHP_SELF')) === $filename) {
$baseUrl = $this->server->get('PHP_SELF');
} elseif (basename($this->server->get('ORIG_SCRIPT_NAME')) === $filename) {
$baseUrl = $this->server->get('ORIG_SCRIPT_NAME');
} else {
$path = $this->server->get('PHP_SELF', '');
$file = $this->server->get('SCRIPT_FILENAME', '');
$segs = explode('/', trim($file, '/'));
$segs = array_reverse($segs);
$index = 0;
$last = count($segs);
$baseUrl = '';
do {
$seg = $segs[$index];
$baseUrl = '/' . $seg . $baseUrl;
++$index;
} while ($last > $index && false !== ($pos = strpos($path, $baseUrl)) && 0 != $pos);
}
$requestUri = $this->getRequestUri();
if ($baseUrl && false !== ($prefix = $this->getUrlencodedPrefix($requestUri, $baseUrl))) {
return $prefix;
}
if ($baseUrl && false !== ($prefix = $this->getUrlencodedPrefix($requestUri, rtrim(dirname($baseUrl), '/' . DIRECTORY_SEPARATOR) . '/'))) {
return rtrim($prefix, '/' . DIRECTORY_SEPARATOR);
}
$truncatedRequestUri = $requestUri;
if (false !== ($pos = strpos($requestUri, '?'))) {
$truncatedRequestUri = substr($requestUri, 0, $pos);
}
$basename = basename($baseUrl);
if (empty($basename) || !strpos(rawurldecode($truncatedRequestUri), $basename)) {
return '';
}
if (strlen($requestUri) >= strlen($baseUrl) && false !== ($pos = strpos($requestUri, $baseUrl)) && $pos !== 0) {
$baseUrl = substr($requestUri, 0, $pos + strlen($baseUrl));
}
return rtrim($baseUrl, '/' . DIRECTORY_SEPARATOR);
}
protected function prepareBasePath()
{
$filename = basename($this->server->get('SCRIPT_FILENAME'));
$baseUrl = $this->getBaseUrl();
if (empty($baseUrl)) {
return '';
}
if (basename($baseUrl) === $filename) {
$basePath = dirname($baseUrl);
} else {
$basePath = $baseUrl;
}
if ('\\' === DIRECTORY_SEPARATOR) {
$basePath = str_replace('\\', '/', $basePath);
}
return rtrim($basePath, '/');
}
protected function preparePathInfo()
{
$baseUrl = $this->getBaseUrl();
if (null === ($requestUri = $this->getRequestUri())) {
return '/';
}
if ($pos = strpos($requestUri, '?')) {
$requestUri = substr($requestUri, 0, $pos);
}
$pathInfo = substr($requestUri, strlen($baseUrl));
if (null !== $baseUrl && (false === $pathInfo || '' === $pathInfo)) {
return '/';
} elseif (null === $baseUrl) {
return $requestUri;
}
return (string) $pathInfo;
}
protected static function initializeFormats()
{
static::$formats = array('html' => array('text/html', 'application/xhtml+xml'), 'txt' => array('text/plain'), 'js' => array('application/javascript', 'application/x-javascript', 'text/javascript'), 'css' => array('text/css'), 'json' => array('application/json', 'application/x-json'), 'xml' => array('text/xml', 'application/xml', 'application/x-xml'), 'rdf' => array('application/rdf+xml'), 'atom' => array('application/atom+xml'), 'rss' => array('application/rss+xml'), 'form' => array('application/x-www-form-urlencoded'));
}
private function setPhpDefaultLocale($locale)
{
try {
if (class_exists('Locale', false)) {
\Locale::setDefault($locale);
}
} catch (\Exception $e) {
}
}
private function getUrlencodedPrefix($string, $prefix)
{
if (0 !== strpos(rawurldecode($string), $prefix)) {
return false;
}
$len = strlen($prefix);
if (preg_match(sprintf('#^(%%[[:xdigit:]]{2}|.){%d}#', $len), $string, $match)) {
return $match[0];
}
return false;
}
private static function createRequestFromFactory(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
{
if (self::$requestFactory) {
$request = call_user_func(self::$requestFactory, $query, $request, $attributes, $cookies, $files, $server, $content);
if (!$request instanceof self) {
throw new \LogicException('The Request factory must return an instance of Symfony\\Component\\HttpFoundation\\Request.');
}
return $request;
}
return new static($query, $request, $attributes, $cookies, $files, $server, $content);
}
private function isFromTrustedProxy()
{
return self::$trustedProxies && IpUtils::checkIp($this->server->get('REMOTE_ADDR'), self::$trustedProxies);
}
private function normalizeAndFilterClientIps(array $clientIps, $ip)
{
$clientIps[] = $ip;
$firstTrustedIp = null;
foreach ($clientIps as $key => $clientIp) {
if (preg_match('{((?:\\d+\\.){3}\\d+)\\:\\d+}', $clientIp, $match)) {
$clientIps[$key] = $clientIp = $match[1];
}
if (!filter_var($clientIp, FILTER_VALIDATE_IP)) {
unset($clientIps[$key]);
continue;
}
if (IpUtils::checkIp($clientIp, self::$trustedProxies)) {
unset($clientIps[$key]);
if (null === $firstTrustedIp) {
$firstTrustedIp = $clientIp;
}
}
}
return $clientIps ? array_reverse($clientIps) : array($firstTrustedIp);
}
}
}
namespace Symfony\Component\HttpFoundation {
class ParameterBag implements \IteratorAggregate, \Countable
{
protected $parameters;
public function __construct(array $parameters = array())
{
$this->parameters = $parameters;
}
public function all()
{
return $this->parameters;
}
public function keys()
{
return array_keys($this->parameters);
}
public function replace(array $parameters = array())
{
$this->parameters = $parameters;
}
public function add(array $parameters = array())
{
$this->parameters = array_replace($this->parameters, $parameters);
}
public function get($key, $default = null)
{
return array_key_exists($key, $this->parameters) ? $this->parameters[$key] : $default;
}
public function set($key, $value)
{
$this->parameters[$key] = $value;
}
public function has($key)
{
return array_key_exists($key, $this->parameters);
}
public function remove($key)
{
unset($this->parameters[$key]);
}
public function getAlpha($key, $default = '')
{
return preg_replace('/[^[:alpha:]]/', '', $this->get($key, $default));
}
public function getAlnum($key, $default = '')
{
return preg_replace('/[^[:alnum:]]/', '', $this->get($key, $default));
}
public function getDigits($key, $default = '')
{
return str_replace(array('-', '+'), '', $this->filter($key, $default, FILTER_SANITIZE_NUMBER_INT));
}
public function getInt($key, $default = 0)
{
return (int) $this->get($key, $default);
}
public function getBoolean($key, $default = false)
{
return $this->filter($key, $default, FILTER_VALIDATE_BOOLEAN);
}
public function filter($key, $default = null, $filter = FILTER_DEFAULT, $options = array())
{
$value = $this->get($key, $default);
if (!is_array($options) && $options) {
$options = array('flags' => $options);
}
if (is_array($value) && !isset($options['flags'])) {
$options['flags'] = FILTER_REQUIRE_ARRAY;
}
return filter_var($value, $filter, $options);
}
public function getIterator()
{
return new \ArrayIterator($this->parameters);
}
public function count()
{
return count($this->parameters);
}
}
}
namespace Symfony\Component\HttpFoundation {
use Symfony\Component\HttpFoundation\File\UploadedFile;
class FileBag extends ParameterBag
{
private static $fileKeys = array('error', 'name', 'size', 'tmp_name', 'type');
public function __construct(array $parameters = array())
{
$this->replace($parameters);
}
public function replace(array $files = array())
{
$this->parameters = array();
$this->add($files);
}
public function set($key, $value)
{
if (!is_array($value) && !$value instanceof UploadedFile) {
throw new \InvalidArgumentException('An uploaded file must be an array or an instance of UploadedFile.');
}
parent::set($key, $this->convertFileInformation($value));
}
public function add(array $files = array())
{
foreach ($files as $key => $file) {
$this->set($key, $file);
}
}
protected function convertFileInformation($file)
{
if ($file instanceof UploadedFile) {
return $file;
}
$file = $this->fixPhpFilesArray($file);
if (is_array($file)) {
$keys = array_keys($file);
sort($keys);
if ($keys == self::$fileKeys) {
if (UPLOAD_ERR_NO_FILE == $file['error']) {
$file = null;
} else {
$file = new UploadedFile($file['tmp_name'], $file['name'], $file['type'], $file['size'], $file['error']);
}
} else {
$file = array_map(array($this, 'convertFileInformation'), $file);
}
}
return $file;
}
protected function fixPhpFilesArray($data)
{
if (!is_array($data)) {
return $data;
}
$keys = array_keys($data);
sort($keys);
if (self::$fileKeys != $keys || !isset($data['name']) || !is_array($data['name'])) {
return $data;
}
$files = $data;
foreach (self::$fileKeys as $k) {
unset($files[$k]);
}
foreach ($data['name'] as $key => $name) {
$files[$key] = $this->fixPhpFilesArray(array('error' => $data['error'][$key], 'name' => $name, 'type' => $data['type'][$key], 'tmp_name' => $data['tmp_name'][$key], 'size' => $data['size'][$key]));
}
return $files;
}
}
}
namespace Symfony\Component\HttpFoundation {
class ServerBag extends ParameterBag
{
public function getHeaders()
{
$headers = array();
$contentHeaders = array('CONTENT_LENGTH' => true, 'CONTENT_MD5' => true, 'CONTENT_TYPE' => true);
foreach ($this->parameters as $key => $value) {
if (0 === strpos($key, 'HTTP_')) {
$headers[substr($key, 5)] = $value;
} elseif (isset($contentHeaders[$key])) {
$headers[$key] = $value;
}
}
if (isset($this->parameters['PHP_AUTH_USER'])) {
$headers['PHP_AUTH_USER'] = $this->parameters['PHP_AUTH_USER'];
$headers['PHP_AUTH_PW'] = isset($this->parameters['PHP_AUTH_PW']) ? $this->parameters['PHP_AUTH_PW'] : '';
} else {
$authorizationHeader = null;
if (isset($this->parameters['HTTP_AUTHORIZATION'])) {
$authorizationHeader = $this->parameters['HTTP_AUTHORIZATION'];
} elseif (isset($this->parameters['REDIRECT_HTTP_AUTHORIZATION'])) {
$authorizationHeader = $this->parameters['REDIRECT_HTTP_AUTHORIZATION'];
}
if (null !== $authorizationHeader) {
if (0 === stripos($authorizationHeader, 'basic ')) {
$exploded = explode(':', base64_decode(substr($authorizationHeader, 6)), 2);
if (count($exploded) == 2) {
list($headers['PHP_AUTH_USER'], $headers['PHP_AUTH_PW']) = $exploded;
}
} elseif (empty($this->parameters['PHP_AUTH_DIGEST']) && 0 === stripos($authorizationHeader, 'digest ')) {
$headers['PHP_AUTH_DIGEST'] = $authorizationHeader;
$this->parameters['PHP_AUTH_DIGEST'] = $authorizationHeader;
} elseif (0 === stripos($authorizationHeader, 'bearer ')) {
$headers['AUTHORIZATION'] = $authorizationHeader;
}
}
}
if (isset($headers['AUTHORIZATION'])) {
return $headers;
}
if (isset($headers['PHP_AUTH_USER'])) {
$headers['AUTHORIZATION'] = 'Basic ' . base64_encode($headers['PHP_AUTH_USER'] . ':' . $headers['PHP_AUTH_PW']);
} elseif (isset($headers['PHP_AUTH_DIGEST'])) {
$headers['AUTHORIZATION'] = $headers['PHP_AUTH_DIGEST'];
}
return $headers;
}
}
}
namespace Symfony\Component\HttpFoundation {
class HeaderBag implements \IteratorAggregate, \Countable
{
protected $headers = array();
protected $cacheControl = array();
public function __construct(array $headers = array())
{
foreach ($headers as $key => $values) {
$this->set($key, $values);
}
}
public function __toString()
{
if (!$this->headers) {
return '';
}
$max = max(array_map('strlen', array_keys($this->headers))) + 1;
$content = '';
ksort($this->headers);
foreach ($this->headers as $name => $values) {
$name = implode('-', array_map('ucfirst', explode('-', $name)));
foreach ($values as $value) {
$content .= sprintf("%-{$max}s %s\r\n", $name . ':', $value);
}
}
return $content;
}
public function all()
{
return $this->headers;
}
public function keys()
{
return array_keys($this->headers);
}
public function replace(array $headers = array())
{
$this->headers = array();
$this->add($headers);
}
public function add(array $headers)
{
foreach ($headers as $key => $values) {
$this->set($key, $values);
}
}
public function get($key, $default = null, $first = true)
{
$key = str_replace('_', '-', strtolower($key));
if (!array_key_exists($key, $this->headers)) {
if (null === $default) {
return $first ? null : array();
}
return $first ? $default : array($default);
}
if ($first) {
return count($this->headers[$key]) ? $this->headers[$key][0] : $default;
}
return $this->headers[$key];
}
public function set($key, $values, $replace = true)
{
$key = str_replace('_', '-', strtolower($key));
$values = array_values((array) $values);
if (true === $replace || !isset($this->headers[$key])) {
$this->headers[$key] = $values;
} else {
$this->headers[$key] = array_merge($this->headers[$key], $values);
}
if ('cache-control' === $key) {
$this->cacheControl = $this->parseCacheControl($values[0]);
}
}
public function has($key)
{
return array_key_exists(str_replace('_', '-', strtolower($key)), $this->headers);
}
public function contains($key, $value)
{
return in_array($value, $this->get($key, null, false));
}
public function remove($key)
{
$key = str_replace('_', '-', strtolower($key));
unset($this->headers[$key]);
if ('cache-control' === $key) {
$this->cacheControl = array();
}
}
public function getDate($key, \DateTime $default = null)
{
if (null === ($value = $this->get($key))) {
return $default;
}
if (false === ($date = \DateTime::createFromFormat(DATE_RFC2822, $value))) {
throw new \RuntimeException(sprintf('The %s HTTP header is not parseable (%s).', $key, $value));
}
return $date;
}
public function addCacheControlDirective($key, $value = true)
{
$this->cacheControl[$key] = $value;
$this->set('Cache-Control', $this->getCacheControlHeader());
}
public function hasCacheControlDirective($key)
{
return array_key_exists($key, $this->cacheControl);
}
public function getCacheControlDirective($key)
{
return array_key_exists($key, $this->cacheControl) ? $this->cacheControl[$key] : null;
}
public function removeCacheControlDirective($key)
{
unset($this->cacheControl[$key]);
$this->set('Cache-Control', $this->getCacheControlHeader());
}
public function getIterator()
{
return new \ArrayIterator($this->headers);
}
public function count()
{
return count($this->headers);
}
protected function getCacheControlHeader()
{
$parts = array();
ksort($this->cacheControl);
foreach ($this->cacheControl as $key => $value) {
if (true === $value) {
$parts[] = $key;
} else {
if (preg_match('#[^a-zA-Z0-9._-]#', $value)) {
$value = '"' . $value . '"';
}
$parts[] = "{$key}={$value}";
}
}
return implode(', ', $parts);
}
protected function parseCacheControl($header)
{
$cacheControl = array();
preg_match_all('#([a-zA-Z][a-zA-Z_-]*)\\s*(?:=(?:"([^"]*)"|([^ \\t",;]*)))?#', $header, $matches, PREG_SET_ORDER);
foreach ($matches as $match) {
$cacheControl[strtolower($match[1])] = isset($match[3]) ? $match[3] : (isset($match[2]) ? $match[2] : true);
}
return $cacheControl;
}
}
}
namespace Symfony\Component\HttpFoundation\Session {
use Symfony\Component\HttpFoundation\Session\Storage\MetadataBag;
interface SessionInterface
{
public function start();
public function getId();
public function setId($id);
public function getName();
public function setName($name);
public function invalidate($lifetime = null);
public function migrate($destroy = false, $lifetime = null);
public function save();
public function has($name);
public function get($name, $default = null);
public function set($name, $value);
public function all();
public function replace(array $attributes);
public function remove($name);
public function clear();
public function isStarted();
public function registerBag(SessionBagInterface $bag);
public function getBag($name);
public function getMetadataBag();
}
}
namespace Symfony\Component\HttpFoundation\Session {
interface SessionBagInterface
{
public function getName();
public function initialize(array &$array);
public function getStorageKey();
public function clear();
}
}
namespace Symfony\Component\HttpFoundation\Session\Attribute {
use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
interface AttributeBagInterface extends SessionBagInterface
{
public function has($name);
public function get($name, $default = null);
public function set($name, $value);
public function all();
public function replace(array $attributes);
public function remove($name);
}
}
namespace Symfony\Component\HttpFoundation\Session\Attribute {
class AttributeBag implements AttributeBagInterface, \IteratorAggregate, \Countable
{
private $name = 'attributes';
private $storageKey;
protected $attributes = array();
public function __construct($storageKey = '_sf2_attributes')
{
$this->storageKey = $storageKey;
}
public function getName()
{
return $this->name;
}
public function setName($name)
{
$this->name = $name;
}
public function initialize(array &$attributes)
{
$this->attributes =& $attributes;
}
public function getStorageKey()
{
return $this->storageKey;
}
public function has($name)
{
return array_key_exists($name, $this->attributes);
}
public function get($name, $default = null)
{
return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : $default;
}
public function set($name, $value)
{
$this->attributes[$name] = $value;
}
public function all()
{
return $this->attributes;
}
public function replace(array $attributes)
{
$this->attributes = array();
foreach ($attributes as $key => $value) {
$this->set($key, $value);
}
}
public function remove($name)
{
$retval = null;
if (array_key_exists($name, $this->attributes)) {
$retval = $this->attributes[$name];
unset($this->attributes[$name]);
}
return $retval;
}
public function clear()
{
$return = $this->attributes;
$this->attributes = array();
return $return;
}
public function getIterator()
{
return new \ArrayIterator($this->attributes);
}
public function count()
{
return count($this->attributes);
}
}
}
namespace Symfony\Component\HttpFoundation\Session\Storage {
use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
class MetadataBag implements SessionBagInterface
{
const CREATED = 'c';
const UPDATED = 'u';
const LIFETIME = 'l';
private $name = '__metadata';
private $storageKey;
protected $meta = array(self::CREATED => 0, self::UPDATED => 0, self::LIFETIME => 0);
private $lastUsed;
private $updateThreshold;
public function __construct($storageKey = '_sf2_meta', $updateThreshold = 0)
{
$this->storageKey = $storageKey;
$this->updateThreshold = $updateThreshold;
}
public function initialize(array &$array)
{
$this->meta =& $array;
if (isset($array[self::CREATED])) {
$this->lastUsed = $this->meta[self::UPDATED];
$timeStamp = time();
if ($timeStamp - $array[self::UPDATED] >= $this->updateThreshold) {
$this->meta[self::UPDATED] = $timeStamp;
}
} else {
$this->stampCreated();
}
}
public function getLifetime()
{
return $this->meta[self::LIFETIME];
}
public function stampNew($lifetime = null)
{
$this->stampCreated($lifetime);
}
public function getStorageKey()
{
return $this->storageKey;
}
public function getCreated()
{
return $this->meta[self::CREATED];
}
public function getLastUsed()
{
return $this->lastUsed;
}
public function clear()
{
}
public function getName()
{
return $this->name;
}
public function setName($name)
{
$this->name = $name;
}
private function stampCreated($lifetime = null)
{
$timeStamp = time();
$this->meta[self::CREATED] = $this->meta[self::UPDATED] = $this->lastUsed = $timeStamp;
$this->meta[self::LIFETIME] = null === $lifetime ? ini_get('session.cookie_lifetime') : $lifetime;
}
}
}
namespace Symfony\Component\HttpFoundation {
class AcceptHeaderItem
{
private $value;
private $quality = 1.0;
private $index = 0;
private $attributes = array();
public function __construct($value, array $attributes = array())
{
$this->value = $value;
foreach ($attributes as $name => $value) {
$this->setAttribute($name, $value);
}
}
public static function fromString($itemValue)
{
$bits = preg_split('/\\s*(?:;*("[^"]+");*|;*(\'[^\']+\');*|;+)\\s*/', $itemValue, 0, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
$value = array_shift($bits);
$attributes = array();
$lastNullAttribute = null;
foreach ($bits as $bit) {
if (($start = substr($bit, 0, 1)) === ($end = substr($bit, -1)) && ($start === '"' || $start === '\'')) {
$attributes[$lastNullAttribute] = substr($bit, 1, -1);
} elseif ('=' === $end) {
$lastNullAttribute = $bit = substr($bit, 0, -1);
$attributes[$bit] = null;
} else {
$parts = explode('=', $bit);
$attributes[$parts[0]] = isset($parts[1]) && strlen($parts[1]) > 0 ? $parts[1] : '';
}
}
return new self(($start = substr($value, 0, 1)) === ($end = substr($value, -1)) && ($start === '"' || $start === '\'') ? substr($value, 1, -1) : $value, $attributes);
}
public function __toString()
{
$string = $this->value . ($this->quality < 1 ? ';q=' . $this->quality : '');
if (count($this->attributes) > 0) {
$string .= ';' . implode(';', array_map(function ($name, $value) {
return sprintf(preg_match('/[,;=]/', $value) ? '%s="%s"' : '%s=%s', $name, $value);
}, array_keys($this->attributes), $this->attributes));
}
return $string;
}
public function setValue($value)
{
$this->value = $value;
return $this;
}
public function getValue()
{
return $this->value;
}
public function setQuality($quality)
{
$this->quality = $quality;
return $this;
}
public function getQuality()
{
return $this->quality;
}
public function setIndex($index)
{
$this->index = $index;
return $this;
}
public function getIndex()
{
return $this->index;
}
public function hasAttribute($name)
{
return isset($this->attributes[$name]);
}
public function getAttribute($name, $default = null)
{
return isset($this->attributes[$name]) ? $this->attributes[$name] : $default;
}
public function getAttributes()
{
return $this->attributes;
}
public function setAttribute($name, $value)
{
if ('q' === $name) {
$this->quality = (double) $value;
} else {
$this->attributes[$name] = (string) $value;
}
return $this;
}
}
}
namespace Symfony\Component\HttpFoundation {
class AcceptHeader
{
private $items = array();
private $sorted = true;
public function __construct(array $items)
{
foreach ($items as $item) {
$this->add($item);
}
}
public static function fromString($headerValue)
{
$index = 0;
return new self(array_map(function ($itemValue) use(&$index) {
$item = AcceptHeaderItem::fromString($itemValue);
$item->setIndex($index++);
return $item;
}, preg_split('/\\s*(?:,*("[^"]+"),*|,*(\'[^\']+\'),*|,+)\\s*/', $headerValue, 0, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE)));
}
public function __toString()
{
return implode(',', $this->items);
}
public function has($value)
{
return isset($this->items[$value]);
}
public function get($value)
{
return isset($this->items[$value]) ? $this->items[$value] : null;
}
public function add(AcceptHeaderItem $item)
{
$this->items[$item->getValue()] = $item;
$this->sorted = false;
return $this;
}
public function all()
{
$this->sort();
return $this->items;
}
public function filter($pattern)
{
return new self(array_filter($this->items, function (AcceptHeaderItem $item) use($pattern) {
return preg_match($pattern, $item->getValue());
}));
}
public function first()
{
$this->sort();
return !empty($this->items) ? reset($this->items) : null;
}
private function sort()
{
if (!$this->sorted) {
uasort($this->items, function ($a, $b) {
$qA = $a->getQuality();
$qB = $b->getQuality();
if ($qA === $qB) {
return $a->getIndex() > $b->getIndex() ? 1 : -1;
}
return $qA > $qB ? -1 : 1;
});
$this->sorted = true;
}
}
}
}
namespace Symfony\Component\Debug {
use Symfony\Component\Debug\Exception\FlattenException;
use Symfony\Component\Debug\Exception\OutOfMemoryException;
class ExceptionHandler
{
private $debug;
private $charset;
private $handler;
private $caughtBuffer;
private $caughtLength;
private $fileLinkFormat;
public function __construct($debug = true, $charset = null, $fileLinkFormat = null)
{
$this->debug = $debug;
$this->charset = $charset ?: ini_get('default_charset') ?: 'UTF-8';
$this->fileLinkFormat = $fileLinkFormat ?: ini_get('xdebug.file_link_format') ?: get_cfg_var('xdebug.file_link_format');
}
public static function register($debug = true, $charset = null, $fileLinkFormat = null)
{
$handler = new static($debug, $charset, $fileLinkFormat);
$prev = set_exception_handler(array($handler, 'handle'));
if (is_array($prev) && $prev[0] instanceof ErrorHandler) {
restore_exception_handler();
$prev[0]->setExceptionHandler(array($handler, 'handle'));
}
return $handler;
}
public function setHandler(callable $handler = null)
{
$old = $this->handler;
$this->handler = $handler;
return $old;
}
public function setFileLinkFormat($format)
{
$old = $this->fileLinkFormat;
$this->fileLinkFormat = $format;
return $old;
}
public function handle(\Exception $exception)
{
if (null === $this->handler || $exception instanceof OutOfMemoryException) {
$this->sendPhpResponse($exception);
return;
}
$caughtLength = $this->caughtLength = 0;
ob_start(function ($buffer) {
$this->caughtBuffer = $buffer;
return '';
});
$this->sendPhpResponse($exception);
while (null === $this->caughtBuffer && ob_end_flush()) {
}
if (isset($this->caughtBuffer[0])) {
ob_start(function ($buffer) {
if ($this->caughtLength) {
$cleanBuffer = substr_replace($buffer, '', 0, $this->caughtLength);
if (isset($cleanBuffer[0])) {
$buffer = $cleanBuffer;
}
}
return $buffer;
});
echo $this->caughtBuffer;
$caughtLength = ob_get_length();
}
$this->caughtBuffer = null;
try {
call_user_func($this->handler, $exception);
$this->caughtLength = $caughtLength;
} catch (\Exception $e) {
if (!$caughtLength) {
throw $exception;
}
}
}
public function sendPhpResponse($exception)
{
if (!$exception instanceof FlattenException) {
$exception = FlattenException::create($exception);
}
if (!headers_sent()) {
header(sprintf('HTTP/1.0 %s', $exception->getStatusCode()));
foreach ($exception->getHeaders() as $name => $value) {
header($name . ': ' . $value, false);
}
header('Content-Type: text/html; charset=' . $this->charset);
}
echo $this->decorate($this->getContent($exception), $this->getStylesheet($exception));
}
public function getHtml($exception)
{
if (!$exception instanceof FlattenException) {
$exception = FlattenException::create($exception);
}
return $this->decorate($this->getContent($exception), $this->getStylesheet($exception));
}
public function getContent(FlattenException $exception)
{
switch ($exception->getStatusCode()) {
case 404:
$title = 'Sorry, the page you are looking for could not be found.';
break;
default:
$title = 'Whoops, looks like something went wrong.';
}
$content = '';
if ($this->debug) {
try {
$count = count($exception->getAllPrevious());
$total = $count + 1;
foreach ($exception->toArray() as $position => $e) {
$ind = $count - $position + 1;
$class = $this->formatClass($e['class']);
$message = nl2br($this->escapeHtml($e['message']));
$content .= sprintf(<<<'EOF'
<h2 class="block_exception clear_fix">
<span class="exception_counter">%d/%d</span>
<span class="exception_title">%s%s:</span>
<span class="exception_message">%s</span>
</h2>
<div class="block">
<ol class="traces list_exception">
EOF
, $ind, $total, $class, $this->formatPath($e['trace'][0]['file'], $e['trace'][0]['line']), $message);
foreach ($e['trace'] as $trace) {
$content .= ' <li>';
if ($trace['function']) {
$content .= sprintf('at %s%s%s(%s)', $this->formatClass($trace['class']), $trace['type'], $trace['function'], $this->formatArgs($trace['args']));
}
if (isset($trace['file']) && isset($trace['line'])) {
$content .= $this->formatPath($trace['file'], $trace['line']);
}
$content .= "</li>\n";
}
$content .= " </ol>\n</div>\n";
}
} catch (\Exception $e) {
if ($this->debug) {
$title = sprintf('Exception thrown when handling an exception (%s: %s)', get_class($e), $this->escapeHtml($e->getMessage()));
} else {
$title = 'Whoops, looks like something went wrong.';
}
}
}
return <<<EOF
<div id="sf-resetcontent" class="sf-reset">
<h1>{$title}</h1>
{$content}
</div>
EOF;
}
public function getStylesheet(FlattenException $exception)
{
return <<<'EOF'
.sf-reset { font: 11px Verdana, Arial, sans-serif; color: #333 }
.sf-reset .clear { clear:both; height:0; font-size:0; line-height:0; }
.sf-reset .clear_fix:after { display:block; height:0; clear:both; visibility:hidden; }
.sf-reset .clear_fix { display:inline-block; }
.sf-reset * html .clear_fix { height:1%; }
.sf-reset .clear_fix { display:block; }
.sf-reset, .sf-reset .block { margin: auto }
.sf-reset abbr { border-bottom: 1px dotted #000; cursor: help; }
.sf-reset p { font-size:14px; line-height:20px; color:#868686; padding-bottom:20px }
.sf-reset strong { font-weight:bold; }
.sf-reset a { color:#6c6159; cursor: default; }
.sf-reset a img { border:none; }
.sf-reset a:hover { text-decoration:underline; }
.sf-reset em { font-style:italic; }
.sf-reset h1, .sf-reset h2 { font: 20px Georgia, "Times New Roman", Times, serif }
.sf-reset .exception_counter { background-color: #fff; color: #333; padding: 6px; float: left; margin-right: 10px; float: left; display: block; }
.sf-reset .exception_title { margin-left: 3em; margin-bottom: 0.7em; display: block; }
.sf-reset .exception_message { margin-left: 3em; display: block; }
.sf-reset .traces li { font-size:12px; padding: 2px 4px; list-style-type:decimal; margin-left:20px; }
.sf-reset .block { background-color:#FFFFFF; padding:10px 28px; margin-bottom:20px;
-webkit-border-bottom-right-radius: 16px;
-webkit-border-bottom-left-radius: 16px;
-moz-border-radius-bottomright: 16px;
-moz-border-radius-bottomleft: 16px;
border-bottom-right-radius: 16px;
border-bottom-left-radius: 16px;
border-bottom:1px solid #ccc;
border-right:1px solid #ccc;
border-left:1px solid #ccc;
}
.sf-reset .block_exception { background-color:#ddd; color: #333; padding:20px;
-webkit-border-top-left-radius: 16px;
-webkit-border-top-right-radius: 16px;
-moz-border-radius-topleft: 16px;
-moz-border-radius-topright: 16px;
border-top-left-radius: 16px;
border-top-right-radius: 16px;
border-top:1px solid #ccc;
border-right:1px solid #ccc;
border-left:1px solid #ccc;
overflow: hidden;
word-wrap: break-word;
}
.sf-reset a { background:none; color:#868686; text-decoration:none; }
.sf-reset a:hover { background:none; color:#313131; text-decoration:underline; }
.sf-reset ol { padding: 10px 0; }
.sf-reset h1 { background-color:#FFFFFF; padding: 15px 28px; margin-bottom: 20px;
-webkit-border-radius: 10px;
-moz-border-radius: 10px;
border-radius: 10px;
border: 1px solid #ccc;
}
EOF;
}
private function decorate($content, $css)
{
return <<<EOF
<!DOCTYPE html>
<html>
<head>
<meta charset="{$this->charset}" />
<meta name="robots" content="noindex,nofollow" />
<style>
/* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html */
html{color:#000;background:#FFF;}body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,textarea,p,blockquote,th,td{margin:0;padding:0;}table{border-collapse:collapse;border-spacing:0;}fieldset,img{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}li{list-style:none;}caption,th{text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;font-weight:normal;}q:before,q:after{content:'';}abbr,acronym{border:0;font-variant:normal;}sup{vertical-align:text-top;}sub{vertical-align:text-bottom;}input,textarea,select{font-family:inherit;font-size:inherit;font-weight:inherit;}input,textarea,select{*font-size:100%;}legend{color:#000;}
html { background: #eee; padding: 10px }
img { border: 0; }
#sf-resetcontent { width:970px; margin:0 auto; }
{$css}
</style>
</head>
<body>
{$content}
</body>
</html>
EOF;
}
private function formatClass($class)
{
$parts = explode('\\', $class);
return sprintf('<abbr title="%s">%s</abbr>', $class, array_pop($parts));
}
private function formatPath($path, $line)
{
$path = $this->escapeHtml($path);
$file = preg_match('#[^/\\\\]*$#', $path, $file) ? $file[0] : $path;
if ($linkFormat = $this->fileLinkFormat) {
$link = strtr($this->escapeHtml($linkFormat), array('%f' => $path, '%l' => (int) $line));
return sprintf(' in <a href="%s" title="Go to source">%s line %d</a>', $link, $file, $line);
}
return sprintf(' in <a title="%s line %3$d" ondblclick="var f=this.innerHTML;this.innerHTML=this.title;this.title=f;">%s line %d</a>', $path, $file, $line);
}
private function formatArgs(array $args)
{
$result = array();
foreach ($args as $key => $item) {
if ('object' === $item[0]) {
$formattedValue = sprintf('<em>object</em>(%s)', $this->formatClass($item[1]));
} elseif ('array' === $item[0]) {
$formattedValue = sprintf('<em>array</em>(%s)', is_array($item[1]) ? $this->formatArgs($item[1]) : $item[1]);
} elseif ('string' === $item[0]) {
$formattedValue = sprintf("'%s'", $this->escapeHtml($item[1]));
} elseif ('null' === $item[0]) {
$formattedValue = '<em>null</em>';
} elseif ('boolean' === $item[0]) {
$formattedValue = '<em>' . strtolower(var_export($item[1], true)) . '</em>';
} elseif ('resource' === $item[0]) {
$formattedValue = '<em>resource</em>';
} else {
$formattedValue = str_replace("\n", '', var_export($this->escapeHtml((string) $item[1]), true));
}
$result[] = is_int($key) ? $formattedValue : sprintf("'%s' => %s", $key, $formattedValue);
}
return implode(', ', $result);
}
private function escapeHtml($str)
{
return htmlspecialchars($str, ENT_QUOTES | ENT_SUBSTITUTE, $this->charset);
}
}
}
namespace Illuminate\Support {
use BadMethodCallException;
use Illuminate\Console\Events\ArtisanStarting;
abstract class ServiceProvider
{
protected $app;
protected $defer = false;
protected static $publishes = [];
protected static $publishGroups = [];
public function __construct($app)
{
$this->app = $app;
}
public abstract function register();
protected function mergeConfigFrom($path, $key)
{
$config = $this->app['config']->get($key, []);
$this->app['config']->set($key, array_merge(require $path, $config));
}
protected function loadViewsFrom($path, $namespace)
{
if (is_dir($appPath = $this->app->basePath() . '/resources/views/vendor/' . $namespace)) {
$this->app['view']->addNamespace($namespace, $appPath);
}
$this->app['view']->addNamespace($namespace, $path);
}
protected function loadTranslationsFrom($path, $namespace)
{
$this->app['translator']->addNamespace($namespace, $path);
}
protected function publishes(array $paths, $group = null)
{
$class = static::class;
if (!array_key_exists($class, static::$publishes)) {
static::$publishes[$class] = [];
}
static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);
if ($group) {
if (!array_key_exists($group, static::$publishGroups)) {
static::$publishGroups[$group] = [];
}
static::$publishGroups[$group] = array_merge(static::$publishGroups[$group], $paths);
}
}
public static function pathsToPublish($provider = null, $group = null)
{
if ($provider && $group) {
if (empty(static::$publishes[$provider]) || empty(static::$publishGroups[$group])) {
return [];
}
return array_intersect_key(static::$publishes[$provider], static::$publishGroups[$group]);
}
if ($group && array_key_exists($group, static::$publishGroups)) {
return static::$publishGroups[$group];
}
if ($provider && array_key_exists($provider, static::$publishes)) {
return static::$publishes[$provider];
}
if ($group || $provider) {
return [];
}
$paths = [];
foreach (static::$publishes as $class => $publish) {
$paths = array_merge($paths, $publish);
}
return $paths;
}
public function commands($commands)
{
$commands = is_array($commands) ? $commands : func_get_args();
$events = $this->app['events'];
$events->listen(ArtisanStarting::class, function ($event) use($commands) {
$event->artisan->resolveCommands($commands);
});
}
public function provides()
{
return [];
}
public function when()
{
return [];
}
public function isDeferred()
{
return $this->defer;
}
public static function compiles()
{
return [];
}
public function __call($method, $parameters)
{
if ($method == 'boot') {
return;
}
throw new BadMethodCallException("Call to undefined method [{$method}]");
}
}
}
namespace Illuminate\Support {
class AggregateServiceProvider extends ServiceProvider
{
protected $providers = [];
protected $instances = [];
public function register()
{
$this->instances = [];
foreach ($this->providers as $provider) {
$this->instances[] = $this->app->register($provider);
}
}
public function provides()
{
$provides = [];
foreach ($this->providers as $provider) {
$instance = $this->app->resolveProviderClass($provider);
$provides = array_merge($provides, $instance->provides());
}
return $provides;
}
}
}
namespace Illuminate\Routing {
use Illuminate\Support\ServiceProvider;
use Zend\Diactoros\Response as PsrResponse;
use Symfony\Bridge\PsrHttpMessage\Factory\DiactorosFactory;
class RoutingServiceProvider extends ServiceProvider
{
public function register()
{
$this->registerRouter();
$this->registerUrlGenerator();
$this->registerRedirector();
$this->registerPsrRequest();
$this->registerPsrResponse();
$this->registerResponseFactory();
}
protected function registerRouter()
{
$this->app['router'] = $this->app->share(function ($app) {
return new Router($app['events'], $app);
});
}
protected function registerUrlGenerator()
{
$this->app['url'] = $this->app->share(function ($app) {
$routes = $app['router']->getRoutes();
$app->instance('routes', $routes);
$url = new UrlGenerator($routes, $app->rebinding('request', $this->requestRebinder()));
$url->setSessionResolver(function () {
return $this->app['session'];
});
$app->rebinding('routes', function ($app, $routes) {
$app['url']->setRoutes($routes);
});
return $url;
});
}
protected function requestRebinder()
{
return function ($app, $request) {
$app['url']->setRequest($request);
};
}
protected function registerRedirector()
{
$this->app['redirect'] = $this->app->share(function ($app) {
$redirector = new Redirector($app['url']);
if (isset($app['session.store'])) {
$redirector->setSession($app['session.store']);
}
return $redirector;
});
}
protected function registerPsrRequest()
{
$this->app->bind('Psr\\Http\\Message\\ServerRequestInterface', function ($app) {
return (new DiactorosFactory())->createRequest($app->make('request'));
});
}
protected function registerPsrResponse()
{
$this->app->bind('Psr\\Http\\Message\\ResponseInterface', function ($app) {
return new PsrResponse();
});
}
protected function registerResponseFactory()
{
$this->app->singleton('Illuminate\\Contracts\\Routing\\ResponseFactory', function ($app) {
return new ResponseFactory($app['Illuminate\\Contracts\\View\\Factory'], $app['redirect']);
});
}
}
}
namespace Illuminate\Events {
use Illuminate\Support\ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
public function register()
{
$this->app->singleton('events', function ($app) {
return (new Dispatcher($app))->setQueueResolver(function () use($app) {
return $app->make('Illuminate\\Contracts\\Queue\\Factory');
});
});
}
}
}
namespace Illuminate\Validation {
use Illuminate\Support\ServiceProvider;
class ValidationServiceProvider extends ServiceProvider
{
protected $defer = true;
public function register()
{
$this->registerPresenceVerifier();
$this->registerValidationFactory();
}
protected function registerValidationFactory()
{
$this->app->singleton('validator', function ($app) {
$validator = new Factory($app['translator'], $app);
if (isset($app['validation.presence'])) {
$validator->setPresenceVerifier($app['validation.presence']);
}
return $validator;
});
}
protected function registerPresenceVerifier()
{
$this->app->singleton('validation.presence', function ($app) {
return new DatabasePresenceVerifier($app['db']);
});
}
public function provides()
{
return ['validator', 'validation.presence'];
}
}
}
namespace Illuminate\Foundation\Validation {
use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;
use Illuminate\Routing\UrlGenerator;
use Illuminate\Contracts\Validation\Factory;
use Illuminate\Contracts\Validation\Validator;
trait ValidatesRequests
{
protected $validatesRequestErrorBag;
public function validateWith($validator, Request $request = null)
{
$request = $request ?: app('request');
if (is_array($validator)) {
$validator = $this->getValidationFactory()->make($request->all(), $validator);
}
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
}
public function validate(Request $request, array $rules, array $messages = [], array $customAttributes = [])
{
$validator = $this->getValidationFactory()->make($request->all(), $rules, $messages, $customAttributes);
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
}
public function validateWithBag($errorBag, Request $request, array $rules, array $messages = [], array $customAttributes = [])
{
$this->withErrorBag($errorBag, function () use($request, $rules, $messages, $customAttributes) {
$this->validate($request, $rules, $messages, $customAttributes);
});
}
protected function throwValidationException(Request $request, $validator)
{
throw new ValidationException($validator, $this->buildFailedValidationResponse($request, $this->formatValidationErrors($validator)));
}
protected function buildFailedValidationResponse(Request $request, array $errors)
{
if ($request->ajax() && !$request->pjax() || $request->wantsJson()) {
return new JsonResponse($errors, 422);
}
return redirect()->to($this->getRedirectUrl())->withInput($request->input())->withErrors($errors, $this->errorBag());
}
protected function formatValidationErrors(Validator $validator)
{
return $validator->errors()->getMessages();
}
protected function getRedirectUrl()
{
return app(UrlGenerator::class)->previous();
}
protected function getValidationFactory()
{
return app(Factory::class);
}
protected function withErrorBag($errorBag, callable $callback)
{
$this->validatesRequestErrorBag = $errorBag;
call_user_func($callback);
$this->validatesRequestErrorBag = null;
}
protected function errorBag()
{
return $this->validatesRequestErrorBag ?: 'default';
}
}
}
namespace Illuminate\Validation {
use Illuminate\Contracts\Validation\UnauthorizedException;
use Illuminate\Contracts\Validation\ValidationException as ValidationExceptionContract;
trait ValidatesWhenResolvedTrait
{
public function validate()
{
$instance = $this->getValidatorInstance();
if (!$this->passesAuthorization()) {
$this->failedAuthorization();
} elseif (!$instance->passes()) {
$this->failedValidation($instance);
}
}
protected function getValidatorInstance()
{
return $this->validator();
}
protected function failedValidation(Validator $validator)
{
throw new ValidationExceptionContract($validator);
}
protected function passesAuthorization()
{
if (method_exists($this, 'authorize')) {
return $this->authorize();
}
return true;
}
protected function failedAuthorization()
{
throw new UnauthorizedException();
}
}
}
namespace Illuminate\Foundation\Auth\Access {
use Illuminate\Contracts\Auth\Access\Gate;
trait AuthorizesRequests
{
public function authorize($ability, $arguments = [])
{
list($ability, $arguments) = $this->parseAbilityAndArguments($ability, $arguments);
return app(Gate::class)->authorize($ability, $arguments);
}
public function authorizeForUser($user, $ability, $arguments = [])
{
list($ability, $arguments) = $this->parseAbilityAndArguments($ability, $arguments);
return app(Gate::class)->forUser($user)->authorize($ability, $arguments);
}
protected function parseAbilityAndArguments($ability, $arguments)
{
if (is_string($ability)) {
return [$ability, $arguments];
}
return [debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2]['function'], $ability];
}
}
}
namespace Illuminate\Foundation\Http {
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Http\JsonResponse;
use Illuminate\Routing\Redirector;
use Illuminate\Container\Container;
use Illuminate\Contracts\Validation\Validator;
use Illuminate\Http\Exception\HttpResponseException;
use Illuminate\Validation\ValidatesWhenResolvedTrait;
use Illuminate\Contracts\Validation\ValidatesWhenResolved;
use Illuminate\Contracts\Validation\Factory as ValidationFactory;
class FormRequest extends Request implements ValidatesWhenResolved
{
use ValidatesWhenResolvedTrait;
protected $container;
protected $redirector;
protected $redirect;
protected $redirectRoute;
protected $redirectAction;
protected $errorBag = 'default';
protected $dontFlash = ['password', 'password_confirmation'];
protected function getValidatorInstance()
{
$factory = $this->container->make(ValidationFactory::class);
if (method_exists($this, 'validator')) {
return $this->container->call([$this, 'validator'], compact('factory'));
}
return $factory->make($this->validationData(), $this->container->call([$this, 'rules']), $this->messages(), $this->attributes());
}
protected function validationData()
{
return $this->all();
}
protected function failedValidation(Validator $validator)
{
throw new HttpResponseException($this->response($this->formatErrors($validator)));
}
protected function passesAuthorization()
{
if (method_exists($this, 'authorize')) {
return $this->container->call([$this, 'authorize']);
}
return false;
}
protected function failedAuthorization()
{
throw new HttpResponseException($this->forbiddenResponse());
}
public function response(array $errors)
{
if ($this->ajax() && !$this->pjax() || $this->wantsJson()) {
return new JsonResponse($errors, 422);
}
return $this->redirector->to($this->getRedirectUrl())->withInput($this->except($this->dontFlash))->withErrors($errors, $this->errorBag);
}
public function forbiddenResponse()
{
return new Response('Forbidden', 403);
}
protected function formatErrors(Validator $validator)
{
return $validator->getMessageBag()->toArray();
}
protected function getRedirectUrl()
{
$url = $this->redirector->getUrlGenerator();
if ($this->redirect) {
return $url->to($this->redirect);
} elseif ($this->redirectRoute) {
return $url->route($this->redirectRoute);
} elseif ($this->redirectAction) {
return $url->action($this->redirectAction);
}
return $url->previous();
}
public function setRedirector(Redirector $redirector)
{
$this->redirector = $redirector;
return $this;
}
public function setContainer(Container $container)
{
$this->container = $container;
return $this;
}
public function messages()
{
return [];
}
public function attributes()
{
return [];
}
}
}
namespace Illuminate\Foundation\Bus {
use Illuminate\Contracts\Bus\Dispatcher;
trait DispatchesJobs
{
protected function dispatch($job)
{
return app(Dispatcher::class)->dispatch($job);
}
public function dispatchNow($job)
{
return app(Dispatcher::class)->dispatchNow($job);
}
}
}
namespace Illuminate\Foundation\Providers {
use Illuminate\Routing\Redirector;
use Illuminate\Support\ServiceProvider;
use Illuminate\Foundation\Http\FormRequest;
use Symfony\Component\HttpFoundation\Request;
use Illuminate\Contracts\Validation\ValidatesWhenResolved;
class FoundationServiceProvider extends ServiceProvider
{
public function register()
{
}
public function boot()
{
$this->configureFormRequests();
}
protected function configureFormRequests()
{
$this->app->afterResolving(function (ValidatesWhenResolved $resolved) {
$resolved->validate();
});
$this->app->resolving(function (FormRequest $request, $app) {
$this->initializeRequest($request, $app['request']);
$request->setContainer($app)->setRedirector($app->make(Redirector::class));
});
}
protected function initializeRequest(FormRequest $form, Request $current)
{
$files = $current->files->all();
$files = is_array($files) ? array_filter($files) : $files;
$form->initialize($current->query->all(), $current->request->all(), $current->attributes->all(), $current->cookies->all(), $files, $current->server->all(), $current->getContent());
if ($session = $current->getSession()) {
$form->setSession($session);
}
$form->setUserResolver($current->getUserResolver());
$form->setRouteResolver($current->getRouteResolver());
}
}
}
namespace Illuminate\Auth {
use Illuminate\Auth\Access\Gate;
use Illuminate\Support\ServiceProvider;
use Illuminate\Contracts\Auth\Access\Gate as GateContract;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
class AuthServiceProvider extends ServiceProvider
{
public function register()
{
$this->registerAuthenticator();
$this->registerUserResolver();
$this->registerAccessGate();
$this->registerRequestRebindHandler();
}
protected function registerAuthenticator()
{
$this->app->singleton('auth', function ($app) {
$app['auth.loaded'] = true;
return new AuthManager($app);
});
$this->app->singleton('auth.driver', function ($app) {
return $app['auth']->guard();
});
}
protected function registerUserResolver()
{
$this->app->bind(AuthenticatableContract::class, function ($app) {
return call_user_func($app['auth']->userResolver());
});
}
protected function registerAccessGate()
{
$this->app->singleton(GateContract::class, function ($app) {
return new Gate($app, function () use($app) {
return call_user_func($app['auth']->userResolver());
});
});
}
protected function registerRequestRebindHandler()
{
$this->app->rebinding('request', function ($app, $request) {
$request->setUserResolver(function ($guard = null) use($app) {
return call_user_func($app['auth']->userResolver(), $guard);
});
});
}
}
}
namespace Illuminate\Pagination {
use Illuminate\Support\ServiceProvider;
class PaginationServiceProvider extends ServiceProvider
{
public function register()
{
Paginator::currentPathResolver(function () {
return $this->app['request']->url();
});
Paginator::currentPageResolver(function ($pageName = 'page') {
$page = $this->app['request']->input($pageName);
if (filter_var($page, FILTER_VALIDATE_INT) !== false && (int) $page >= 1) {
return $page;
}
return 1;
});
}
}
}
namespace Illuminate\Foundation\Support\Providers {
use Illuminate\Support\ServiceProvider;
use Illuminate\Contracts\Auth\Access\Gate as GateContract;
class AuthServiceProvider extends ServiceProvider
{
protected $policies = [];
public function registerPolicies(GateContract $gate)
{
foreach ($this->policies as $key => $value) {
$gate->policy($key, $value);
}
}
public function register()
{
}
}
}
namespace Illuminate\Foundation\Support\Providers {
use Illuminate\Routing\Router;
use Illuminate\Support\ServiceProvider;
use Illuminate\Contracts\Routing\UrlGenerator;
class RouteServiceProvider extends ServiceProvider
{
protected $namespace;
public function boot(Router $router)
{
$this->setRootControllerNamespace();
if ($this->app->routesAreCached()) {
$this->loadCachedRoutes();
} else {
$this->loadRoutes();
$this->app->booted(function () use($router) {
$router->getRoutes()->refreshNameLookups();
});
}
}
protected function setRootControllerNamespace()
{
if (is_null($this->namespace)) {
return;
}
$this->app[UrlGenerator::class]->setRootControllerNamespace($this->namespace);
}
protected function loadCachedRoutes()
{
$this->app->booted(function () {
require $this->app->getCachedRoutesPath();
});
}
protected function loadRoutes()
{
$this->app->call([$this, 'map']);
}
protected function loadRoutesFrom($path)
{
$router = $this->app->make(Router::class);
if (is_null($this->namespace)) {
return require $path;
}
$router->group(['namespace' => $this->namespace], function (Router $router) use($path) {
require $path;
});
}
public function register()
{
}
public function __call($method, $parameters)
{
return call_user_func_array([$this->app->make(Router::class), $method], $parameters);
}
}
}
namespace Illuminate\Foundation\Support\Providers {
use Illuminate\Support\ServiceProvider;
use Illuminate\Contracts\Events\Dispatcher as DispatcherContract;
class EventServiceProvider extends ServiceProvider
{
protected $listen = [];
protected $subscribe = [];
public function boot(DispatcherContract $events)
{
foreach ($this->listens() as $event => $listeners) {
foreach ($listeners as $listener) {
$events->listen($event, $listener);
}
}
foreach ($this->subscribe as $subscriber) {
$events->subscribe($subscriber);
}
}
public function register()
{
}
public function listens()
{
return $this->listen;
}
}
}
namespace Illuminate\Hashing {
use Illuminate\Support\ServiceProvider;
class HashServiceProvider extends ServiceProvider
{
protected $defer = true;
public function register()
{
$this->app->singleton('hash', function () {
return new BcryptHasher();
});
}
public function provides()
{
return ['hash'];
}
}
}
namespace Illuminate\Hashing {
use RuntimeException;
use Illuminate\Contracts\Hashing\Hasher as HasherContract;
class BcryptHasher implements HasherContract
{
protected $rounds = 10;
public function make($value, array $options = [])
{
$cost = isset($options['rounds']) ? $options['rounds'] : $this->rounds;
$hash = password_hash($value, PASSWORD_BCRYPT, ['cost' => $cost]);
if ($hash === false) {
throw new RuntimeException('Bcrypt hashing not supported.');
}
return $hash;
}
public function check($value, $hashedValue, array $options = [])
{
if (strlen($hashedValue) === 0) {
return false;
}
return password_verify($value, $hashedValue);
}
public function needsRehash($hashedValue, array $options = [])
{
$cost = isset($options['rounds']) ? $options['rounds'] : $this->rounds;
return password_needs_rehash($hashedValue, PASSWORD_BCRYPT, ['cost' => $cost]);
}
public function setRounds($rounds)
{
$this->rounds = (int) $rounds;
return $this;
}
}
}
namespace Illuminate\Contracts\Pagination {
interface Paginator
{
public function url($page);
public function appends($key, $value = null);
public function fragment($fragment = null);
public function nextPageUrl();
public function previousPageUrl();
public function items();
public function firstItem();
public function lastItem();
public function perPage();
public function currentPage();
public function hasPages();
public function hasMorePages();
public function isEmpty();
public function render(Presenter $presenter = null);
}
}
namespace Illuminate\Pagination {
use Closure;
use ArrayIterator;
use Illuminate\Support\Str;
use Illuminate\Support\Collection;
use Illuminate\Contracts\Support\Htmlable;
abstract class AbstractPaginator implements Htmlable
{
protected $items;
protected $perPage;
protected $currentPage;
protected $path = '/';
protected $query = [];
protected $fragment = null;
protected $pageName = 'page';
protected static $currentPathResolver;
protected static $currentPageResolver;
protected static $presenterResolver;
protected function isValidPageNumber($page)
{
return $page >= 1 && filter_var($page, FILTER_VALIDATE_INT) !== false;
}
public function getUrlRange($start, $end)
{
$urls = [];
for ($page = $start; $page <= $end; $page++) {
$urls[$page] = $this->url($page);
}
return $urls;
}
public function url($page)
{
if ($page <= 0) {
$page = 1;
}
$parameters = [$this->pageName => $page];
if (count($this->query) > 0) {
$parameters = array_merge($this->query, $parameters);
}
return $this->path . (Str::contains($this->path, '?') ? '&' : '?') . http_build_query($parameters, '', '&') . $this->buildFragment();
}
public function previousPageUrl()
{
if ($this->currentPage() > 1) {
return $this->url($this->currentPage() - 1);
}
}
public function fragment($fragment = null)
{
if (is_null($fragment)) {
return $this->fragment;
}
$this->fragment = $fragment;
return $this;
}
public function appends($key, $value = null)
{
if (is_array($key)) {
return $this->appendArray($key);
}
return $this->addQuery($key, $value);
}
protected function appendArray(array $keys)
{
foreach ($keys as $key => $value) {
$this->addQuery($key, $value);
}
return $this;
}
public function addQuery($key, $value)
{
if ($key !== $this->pageName) {
$this->query[$key] = $value;
}
return $this;
}
protected function buildFragment()
{
return $this->fragment ? '#' . $this->fragment : '';
}
public function items()
{
return $this->items->all();
}
public function firstItem()
{
if (count($this->items) === 0) {
return;
}
return ($this->currentPage - 1) * $this->perPage + 1;
}
public function lastItem()
{
if (count($this->items) === 0) {
return;
}
return $this->firstItem() + $this->count() - 1;
}
public function perPage()
{
return $this->perPage;
}
public function currentPage()
{
return $this->currentPage;
}
public function hasPages()
{
return !($this->currentPage() == 1 && !$this->hasMorePages());
}
public static function resolveCurrentPath($default = '/')
{
if (isset(static::$currentPathResolver)) {
return call_user_func(static::$currentPathResolver);
}
return $default;
}
public static function currentPathResolver(Closure $resolver)
{
static::$currentPathResolver = $resolver;
}
public static function resolveCurrentPage($pageName = 'page', $default = 1)
{
if (isset(static::$currentPageResolver)) {
return call_user_func(static::$currentPageResolver, $pageName);
}
return $default;
}
public static function currentPageResolver(Closure $resolver)
{
static::$currentPageResolver = $resolver;
}
public static function presenter(Closure $resolver)
{
static::$presenterResolver = $resolver;
}
public function getPageName()
{
return $this->pageName;
}
public function setPageName($name)
{
$this->pageName = $name;
return $this;
}
public function setPath($path)
{
$this->path = $path;
return $this;
}
public function getIterator()
{
return new ArrayIterator($this->items->all());
}
public function isEmpty()
{
return $this->items->isEmpty();
}
public function count()
{
return $this->items->count();
}
public function getCollection()
{
return $this->items;
}
public function setCollection(Collection $collection)
{
$this->items = $collection;
return $this;
}
public function offsetExists($key)
{
return $this->items->has($key);
}
public function offsetGet($key)
{
return $this->items->get($key);
}
public function offsetSet($key, $value)
{
$this->items->put($key, $value);
}
public function offsetUnset($key)
{
$this->items->forget($key);
}
public function toHtml()
{
return (string) $this->render();
}
public function __call($method, $parameters)
{
return call_user_func_array([$this->getCollection(), $method], $parameters);
}
public function __toString()
{
return (string) $this->render();
}
}
}
namespace Illuminate\Pagination {
use Countable;
use ArrayAccess;
use JsonSerializable;
use IteratorAggregate;
use Illuminate\Support\Collection;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Pagination\Presenter;
use Illuminate\Contracts\Pagination\Paginator as PaginatorContract;
class Paginator extends AbstractPaginator implements Arrayable, ArrayAccess, Countable, IteratorAggregate, JsonSerializable, Jsonable, PaginatorContract
{
protected $hasMore;
public function __construct($items, $perPage, $currentPage = null, array $options = [])
{
foreach ($options as $key => $value) {
$this->{$key} = $value;
}
$this->perPage = $perPage;
$this->currentPage = $this->setCurrentPage($currentPage);
$this->path = $this->path != '/' ? rtrim($this->path, '/') : $this->path;
$this->items = $items instanceof Collection ? $items : Collection::make($items);
$this->checkForMorePages();
}
protected function setCurrentPage($currentPage)
{
$currentPage = $currentPage ?: static::resolveCurrentPage();
return $this->isValidPageNumber($currentPage) ? (int) $currentPage : 1;
}
protected function checkForMorePages()
{
$this->hasMore = count($this->items) > $this->perPage;
$this->items = $this->items->slice(0, $this->perPage);
}
public function nextPageUrl()
{
if ($this->hasMorePages()) {
return $this->url($this->currentPage() + 1);
}
}
public function hasMorePages()
{
return $this->hasMore;
}
public function links(Presenter $presenter = null)
{
return $this->render($presenter);
}
public function render(Presenter $presenter = null)
{
if (is_null($presenter) && static::$presenterResolver) {
$presenter = call_user_func(static::$presenterResolver, $this);
}
$presenter = $presenter ?: new SimpleBootstrapThreePresenter($this);
return $presenter->render();
}
public function toArray()
{
return ['per_page' => $this->perPage(), 'current_page' => $this->currentPage(), 'next_page_url' => $this->nextPageUrl(), 'prev_page_url' => $this->previousPageUrl(), 'from' => $this->firstItem(), 'to' => $this->lastItem(), 'data' => $this->items->toArray()];
}
public function jsonSerialize()
{
return $this->toArray();
}
public function toJson($options = 0)
{
return json_encode($this->jsonSerialize(), $options);
}
}
}
namespace Illuminate\Support\Facades {
use Mockery;
use RuntimeException;
use Mockery\MockInterface;
abstract class Facade
{
protected static $app;
protected static $resolvedInstance;
public static function swap($instance)
{
static::$resolvedInstance[static::getFacadeAccessor()] = $instance;
static::$app->instance(static::getFacadeAccessor(), $instance);
}
public static function shouldReceive()
{
$name = static::getFacadeAccessor();
if (static::isMock()) {
$mock = static::$resolvedInstance[$name];
} else {
$mock = static::createFreshMockInstance($name);
}
return call_user_func_array([$mock, 'shouldReceive'], func_get_args());
}
protected static function createFreshMockInstance($name)
{
static::$resolvedInstance[$name] = $mock = static::createMockByName($name);
$mock->shouldAllowMockingProtectedMethods();
if (isset(static::$app)) {
static::$app->instance($name, $mock);
}
return $mock;
}
protected static function createMockByName($name)
{
$class = static::getMockableClass($name);
return $class ? Mockery::mock($class) : Mockery::mock();
}
protected static function isMock()
{
$name = static::getFacadeAccessor();
return isset(static::$resolvedInstance[$name]) && static::$resolvedInstance[$name] instanceof MockInterface;
}
protected static function getMockableClass()
{
if ($root = static::getFacadeRoot()) {
return get_class($root);
}
}
public static function getFacadeRoot()
{
return static::resolveFacadeInstance(static::getFacadeAccessor());
}
protected static function getFacadeAccessor()
{
throw new RuntimeException('Facade does not implement getFacadeAccessor method.');
}
protected static function resolveFacadeInstance($name)
{
if (is_object($name)) {
return $name;
}
if (isset(static::$resolvedInstance[$name])) {
return static::$resolvedInstance[$name];
}
return static::$resolvedInstance[$name] = static::$app[$name];
}
public static function clearResolvedInstance($name)
{
unset(static::$resolvedInstance[$name]);
}
public static function clearResolvedInstances()
{
static::$resolvedInstance = [];
}
public static function getFacadeApplication()
{
return static::$app;
}
public static function setFacadeApplication($app)
{
static::$app = $app;
}
public static function __callStatic($method, $args)
{
$instance = static::getFacadeRoot();
if (!$instance) {
throw new RuntimeException('A facade root has not been set.');
}
switch (count($args)) {
case 0:
return $instance->{$method}();
case 1:
return $instance->{$method}($args[0]);
case 2:
return $instance->{$method}($args[0], $args[1]);
case 3:
return $instance->{$method}($args[0], $args[1], $args[2]);
case 4:
return $instance->{$method}($args[0], $args[1], $args[2], $args[3]);
default:
return call_user_func_array([$instance, $method], $args);
}
}
}
}
namespace Illuminate\Support\Traits {
use Closure;
use BadMethodCallException;
trait Macroable
{
protected static $macros = [];
public static function macro($name, callable $macro)
{
static::$macros[$name] = $macro;
}
public static function hasMacro($name)
{
return isset(static::$macros[$name]);
}
public static function __callStatic($method, $parameters)
{
if (!static::hasMacro($method)) {
throw new BadMethodCallException("Method {$method} does not exist.");
}
if (static::$macros[$method] instanceof Closure) {
return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
}
return call_user_func_array(static::$macros[$method], $parameters);
}
public function __call($method, $parameters)
{
if (!static::hasMacro($method)) {
throw new BadMethodCallException("Method {$method} does not exist.");
}
if (static::$macros[$method] instanceof Closure) {
return call_user_func_array(static::$macros[$method]->bindTo($this, static::class), $parameters);
}
return call_user_func_array(static::$macros[$method], $parameters);
}
}
}
namespace Illuminate\Support {
use ArrayAccess;
use Illuminate\Support\Traits\Macroable;
class Arr
{
use Macroable;
public static function accessible($value)
{
return is_array($value) || $value instanceof ArrayAccess;
}
public static function add($array, $key, $value)
{
if (is_null(static::get($array, $key))) {
static::set($array, $key, $value);
}
return $array;
}
public static function build($array, callable $callback)
{
$results = [];
foreach ($array as $key => $value) {
list($innerKey, $innerValue) = call_user_func($callback, $key, $value);
$results[$innerKey] = $innerValue;
}
return $results;
}
public static function collapse($array)
{
$results = [];
foreach ($array as $values) {
if ($values instanceof Collection) {
$values = $values->all();
} elseif (!is_array($values)) {
continue;
}
$results = array_merge($results, $values);
}
return $results;
}
public static function divide($array)
{
return [array_keys($array), array_values($array)];
}
public static function dot($array, $prepend = '')
{
$results = [];
foreach ($array as $key => $value) {
if (is_array($value) && !empty($value)) {
$results = array_merge($results, static::dot($value, $prepend . $key . '.'));
} else {
$results[$prepend . $key] = $value;
}
}
return $results;
}
public static function except($array, $keys)
{
static::forget($array, $keys);
return $array;
}
public static function exists($array, $key)
{
if ($array instanceof ArrayAccess) {
return $array->offsetExists($key);
}
return array_key_exists($key, $array);
}
public static function first($array, callable $callback = null, $default = null)
{
if (is_null($callback)) {
return empty($array) ? value($default) : reset($array);
}
foreach ($array as $key => $value) {
if (call_user_func($callback, $key, $value)) {
return $value;
}
}
return value($default);
}
public static function last($array, callable $callback = null, $default = null)
{
if (is_null($callback)) {
return empty($array) ? value($default) : end($array);
}
return static::first(array_reverse($array), $callback, $default);
}
public static function flatten($array, $depth = INF)
{
$result = [];
foreach ($array as $item) {
$item = $item instanceof Collection ? $item->all() : $item;
if (is_array($item)) {
if ($depth === 1) {
$result = array_merge($result, $item);
continue;
}
$result = array_merge($result, static::flatten($item, $depth - 1));
continue;
}
$result[] = $item;
}
return $result;
}
public static function forget(&$array, $keys)
{
$original =& $array;
$keys = (array) $keys;
if (count($keys) === 0) {
return;
}
foreach ($keys as $key) {
if (static::exists($array, $key)) {
unset($array[$key]);
continue;
}
$parts = explode('.', $key);
$array =& $original;
while (count($parts) > 1) {
$part = array_shift($parts);
if (isset($array[$part]) && is_array($array[$part])) {
$array =& $array[$part];
} else {
continue 2;
}
}
unset($array[array_shift($parts)]);
}
}
public static function get($array, $key, $default = null)
{
if (!static::accessible($array)) {
return value($default);
}
if (is_null($key)) {
return $array;
}
if (static::exists($array, $key)) {
return $array[$key];
}
foreach (explode('.', $key) as $segment) {
if (static::accessible($array) && static::exists($array, $segment)) {
$array = $array[$segment];
} else {
return value($default);
}
}
return $array;
}
public static function has($array, $key)
{
if (!$array) {
return false;
}
if (is_null($key)) {
return false;
}
if (static::exists($array, $key)) {
return true;
}
foreach (explode('.', $key) as $segment) {
if (static::accessible($array) && static::exists($array, $segment)) {
$array = $array[$segment];
} else {
return false;
}
}
return true;
}
public static function isAssoc(array $array)
{
$keys = array_keys($array);
return array_keys($keys) !== $keys;
}
public static function only($array, $keys)
{
return array_intersect_key($array, array_flip((array) $keys));
}
public static function pluck($array, $value, $key = null)
{
$results = [];
list($value, $key) = static::explodePluckParameters($value, $key);
foreach ($array as $item) {
$itemValue = data_get($item, $value);
if (is_null($key)) {
$results[] = $itemValue;
} else {
$itemKey = data_get($item, $key);
$results[$itemKey] = $itemValue;
}
}
return $results;
}
protected static function explodePluckParameters($value, $key)
{
$value = is_string($value) ? explode('.', $value) : $value;
$key = is_null($key) || is_array($key) ? $key : explode('.', $key);
return [$value, $key];
}
public static function prepend($array, $value, $key = null)
{
if (is_null($key)) {
array_unshift($array, $value);
} else {
$array = [$key => $value] + $array;
}
return $array;
}
public static function pull(&$array, $key, $default = null)
{
$value = static::get($array, $key, $default);
static::forget($array, $key);
return $value;
}
public static function set(&$array, $key, $value)
{
if (is_null($key)) {
return $array = $value;
}
$keys = explode('.', $key);
while (count($keys) > 1) {
$key = array_shift($keys);
if (!isset($array[$key]) || !is_array($array[$key])) {
$array[$key] = [];
}
$array =& $array[$key];
}
$array[array_shift($keys)] = $value;
return $array;
}
public static function sort($array, callable $callback)
{
return Collection::make($array)->sortBy($callback)->all();
}
public static function sortRecursive($array)
{
foreach ($array as &$value) {
if (is_array($value)) {
$value = static::sortRecursive($value);
}
}
if (static::isAssoc($array)) {
ksort($array);
} else {
sort($array);
}
return $array;
}
public static function where($array, callable $callback)
{
$filtered = [];
foreach ($array as $key => $value) {
if (call_user_func($callback, $key, $value)) {
$filtered[$key] = $value;
}
}
return $filtered;
}
}
}
Directory Contents
Dirs: 0 × Files: 3