/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/View
/FileViewFinder.php
/**
* Find the given view in the list of paths.
*
* @param string $name
* @param array $paths
* @return string
*
* @throws \InvalidArgumentException
*/
protected function findInPaths($name, $paths)
{
foreach ((array) $paths as $path) {
foreach ($this->getPossibleViewFiles($name) as $file) {
if ($this->files->exists($viewPath = $path.'/'.$file)) {
return $viewPath;
}
}
}
throw new InvalidArgumentException("View [{$name}] not found.");
}
/**
* Get an array of possible view files.
*
* @param string $name
* @return array
*/
protected function getPossibleViewFiles($name)
{
return array_map(function ($extension) use ($name) {
return str_replace('.', '/', $name).'.'.$extension;
}, $this->extensions);
}
/**
* Add a location to the finder.
*
* @param string $location
* @return void
Arguments
"View [errors.404] not found."
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/View
/FileViewFinder.php
}
}
/**
* Get the fully qualified location of the view.
*
* @param string $name
* @return string
*/
public function find($name)
{
if (isset($this->views[$name])) {
return $this->views[$name];
}
if ($this->hasHintInformation($name = trim($name))) {
return $this->views[$name] = $this->findNamespacedView($name);
}
return $this->views[$name] = $this->findInPaths($name, $this->paths);
}
/**
* Get the path to a template with a named path.
*
* @param string $name
* @return string
*/
protected function findNamespacedView($name)
{
[$namespace, $view] = $this->parseNamespaceSegments($name);
return $this->findInPaths($view, $this->hints[$namespace]);
}
/**
* Get the segments of a template with a named path.
*
* @param string $name
* @return array
Arguments
"errors.404"
array:1 [
0 => "/var/www/goodschool/campus/casyymps-demo/resources/views"
]
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/View
/Factory.php
{
$data = array_merge($mergeData, $this->parseData($data));
return tap($this->viewInstance($path, $path, $data), function ($view) {
$this->callCreator($view);
});
}
/**
* Get the evaluated view contents for the given view.
*
* @param string $view
* @param \Illuminate\Contracts\Support\Arrayable|array $data
* @param array $mergeData
* @return \Illuminate\Contracts\View\View
*/
public function make($view, $data = [], $mergeData = [])
{
$path = $this->finder->find(
$view = $this->normalizeName($view)
);
// Next, we will create the view instance and call the view creator for the view
// which can set any data, etc. Then we will return the view instance back to
// the caller for rendering or performing other view manipulations on this.
$data = array_merge($mergeData, $this->parseData($data));
return tap($this->viewInstance($view, $path, $data), function ($view) {
$this->callCreator($view);
});
}
/**
* Get the first view that actually exists from the given list.
*
* @param array $views
* @param \Illuminate\Contracts\Support\Arrayable|array $data
* @param array $mergeData
* @return \Illuminate\Contracts\View\View
*
Arguments
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/ResponseFactory.php
* @param array $headers
* @return \Illuminate\Http\Response
*/
public function noContent($status = 204, array $headers = [])
{
return $this->make('', $status, $headers);
}
/**
* Create a new response for a given view.
*
* @param string $view
* @param array $data
* @param int $status
* @param array $headers
* @return \Illuminate\Http\Response
*/
public function view($view, $data = [], $status = 200, array $headers = [])
{
return $this->make($this->view->make($view, $data), $status, $headers);
}
/**
* Create a new JSON response instance.
*
* @param mixed $data
* @param int $status
* @param array $headers
* @param int $options
* @return \Illuminate\Http\JsonResponse
*/
public function json($data = [], $status = 200, array $headers = [], $options = 0)
{
return new JsonResponse($data, $status, $headers, $options);
}
/**
* Create a new JSONP response instance.
*
* @param string $callback
Arguments
/var
/www
/goodschool
/campus
/casyymps-demo
/app
/Exceptions
/Handler.php
public function report(Exception $exception)
{
parent::report($exception);
}
/**
* Render an exception into an HTTP response.
*
* @param \Illuminate\Http\Request $request
* @param \Exception $exception
* @return \Illuminate\Http\Response
*/
public function render($request, Exception $exception)
{
// dd($exception);
if($this->isHttpException($exception) && env('APP_DEBUG') != false){
switch($exception->getStatusCode()){
case 404:
return response()->view('errors.404');
// return response()->view('errors' . '404', [], 404);
// return redirect()->away('');
// return redirect()->route('home');
break;
case 505:
return response()->view('errors.505');
break;
case 419:
return redirect()->route('index');
break;
default:
return $this->renderHttpException($exception);
break;
}
}else{
// return redirect()->route('index');
return parent::render($request, $exception);
}
}
}
Arguments
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
if (! $this->container->bound(ExceptionHandler::class) ||
! $passable instanceof Request) {
throw $e;
}
$handler = $this->container->make(ExceptionHandler::class);
$handler->report($e);
$response = $handler->render($passable, $e);
if (method_exists($response, 'withException')) {
$response->withException($e);
}
return $response;
}
}
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
NotFoundHttpException {#687
-statusCode: 404
-headers: []
#message: ""
#code: 0
#file: "/var/www/goodschool/campus/casyymps-demo/vendor/laravel/framework/src/Illuminate/Routing/RouteCollection.php"
#line: 179
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
/**
* This extended pipeline catches any exceptions that occur during each slice.
*
* The exceptions are converted to HTTP responses for proper middleware handling.
*/
class Pipeline extends BasePipeline
{
/**
* Get the final piece of the Closure onion.
*
* @param \Closure $destination
* @return \Closure
*/
protected function prepareDestination(Closure $destination)
{
return function ($passable) use ($destination) {
try {
return $destination($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
NotFoundHttpException {#687
-statusCode: 404
-headers: []
#message: ""
#code: 0
#file: "/var/www/goodschool/campus/casyymps-demo/vendor/laravel/framework/src/Illuminate/Routing/RouteCollection.php"
#line: 179
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/fideloper
/proxy
/src
/TrustProxies.php
{
$this->config = $config;
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
*
* @throws \Symfony\Component\HttpKernel\Exception\HttpException
*
* @return mixed
*/
public function handle(Request $request, Closure $next)
{
$request::setTrustedProxies([], $this->getTrustedHeaderNames()); // Reset trusted proxies between requests
$this->setTrustedProxyIpAddresses($request);
return $next($request);
}
/**
* Sets the trusted proxies on the request to the value of trustedproxy.proxies
*
* @param \Illuminate\Http\Request $request
*/
protected function setTrustedProxyIpAddresses(Request $request)
{
$trustedIps = $this->proxies ?: $this->config->get('trustedproxy.proxies');
// Only trust specific IP addresses
if (is_array($trustedIps)) {
return $this->setTrustedProxyIpAddressesToSpecificIps($request, $trustedIps);
}
// Trust any IP address that calls us
// `**` for backwards compatibility, but is depreciated
if ($trustedIps === '*' || $trustedIps === '**') {
return $this->setTrustedProxyIpAddressesToTheCallingIp($request);
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
// the appropriate method and arguments, returning the results back out.
return $pipe($passable, $stack);
} elseif (! is_object($pipe)) {
[$name, $parameters] = $this->parsePipeString($pipe);
// If the pipe is a string we will parse the string and resolve the class out
// of the dependency injection container. We can then build a callable and
// execute the pipe function giving in the parameters that are required.
$pipe = $this->getContainer()->make($name);
$parameters = array_merge([$passable, $stack], $parameters);
} else {
// If the pipe is already an object we'll just make a callable and pass it to
// the pipe as-is. There is no need to do any extra parsing and formatting
// since the object we're given was already a fully instantiated object.
$parameters = [$passable, $stack];
}
$response = method_exists($pipe, $this->method)
? $pipe->{$this->method}(...$parameters)
: $pipe(...$parameters);
return $response instanceof Responsable
? $response->toResponse($this->container->make(Request::class))
: $response;
};
};
}
/**
* Parse full pipe string to get name and parameters.
*
* @param string $pipe
* @return array
*/
protected function parsePipeString($pipe)
{
[$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, []);
if (is_string($parameters)) {
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
Closure {#340
class: "Illuminate\Routing\Pipeline"
this: Pipeline {#30 …}
parameters: {
$passable: {}
}
use: {
$destination: Closure {#22 …}
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
return $callable($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
};
}
/**
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Middleware
/TransformsRequest.php
*
* @var array
*/
protected $attributes = [];
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @param array ...$attributes
* @return mixed
*/
public function handle($request, Closure $next, ...$attributes)
{
$this->attributes = $attributes;
$this->clean($request);
return $next($request);
}
/**
* Clean the request's data.
*
* @param \Illuminate\Http\Request $request
* @return void
*/
protected function clean($request)
{
$this->cleanParameterBag($request->query);
if ($request->isJson()) {
$this->cleanParameterBag($request->json());
} elseif ($request->request !== $request->query) {
$this->cleanParameterBag($request->request);
}
}
/**
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
// the appropriate method and arguments, returning the results back out.
return $pipe($passable, $stack);
} elseif (! is_object($pipe)) {
[$name, $parameters] = $this->parsePipeString($pipe);
// If the pipe is a string we will parse the string and resolve the class out
// of the dependency injection container. We can then build a callable and
// execute the pipe function giving in the parameters that are required.
$pipe = $this->getContainer()->make($name);
$parameters = array_merge([$passable, $stack], $parameters);
} else {
// If the pipe is already an object we'll just make a callable and pass it to
// the pipe as-is. There is no need to do any extra parsing and formatting
// since the object we're given was already a fully instantiated object.
$parameters = [$passable, $stack];
}
$response = method_exists($pipe, $this->method)
? $pipe->{$this->method}(...$parameters)
: $pipe(...$parameters);
return $response instanceof Responsable
? $response->toResponse($this->container->make(Request::class))
: $response;
};
};
}
/**
* Parse full pipe string to get name and parameters.
*
* @param string $pipe
* @return array
*/
protected function parsePipeString($pipe)
{
[$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, []);
if (is_string($parameters)) {
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
Closure {#652
class: "Illuminate\Routing\Pipeline"
this: Pipeline {#30 …}
parameters: {
$passable: {}
}
use: {
$stack: Closure {#340 …}
$pipe: "App\Http\Middleware\TrustProxies"
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
return $callable($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
};
}
/**
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Middleware
/TransformsRequest.php
*
* @var array
*/
protected $attributes = [];
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @param array ...$attributes
* @return mixed
*/
public function handle($request, Closure $next, ...$attributes)
{
$this->attributes = $attributes;
$this->clean($request);
return $next($request);
}
/**
* Clean the request's data.
*
* @param \Illuminate\Http\Request $request
* @return void
*/
protected function clean($request)
{
$this->cleanParameterBag($request->query);
if ($request->isJson()) {
$this->cleanParameterBag($request->json());
} elseif ($request->request !== $request->query) {
$this->cleanParameterBag($request->request);
}
}
/**
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
// the appropriate method and arguments, returning the results back out.
return $pipe($passable, $stack);
} elseif (! is_object($pipe)) {
[$name, $parameters] = $this->parsePipeString($pipe);
// If the pipe is a string we will parse the string and resolve the class out
// of the dependency injection container. We can then build a callable and
// execute the pipe function giving in the parameters that are required.
$pipe = $this->getContainer()->make($name);
$parameters = array_merge([$passable, $stack], $parameters);
} else {
// If the pipe is already an object we'll just make a callable and pass it to
// the pipe as-is. There is no need to do any extra parsing and formatting
// since the object we're given was already a fully instantiated object.
$parameters = [$passable, $stack];
}
$response = method_exists($pipe, $this->method)
? $pipe->{$this->method}(...$parameters)
: $pipe(...$parameters);
return $response instanceof Responsable
? $response->toResponse($this->container->make(Request::class))
: $response;
};
};
}
/**
* Parse full pipe string to get name and parameters.
*
* @param string $pipe
* @return array
*/
protected function parsePipeString($pipe)
{
[$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, []);
if (is_string($parameters)) {
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
Closure {#664
class: "Illuminate\Routing\Pipeline"
this: Pipeline {#30 …}
parameters: {
$passable: {}
}
use: {
$stack: Closure {#652 …}
$pipe: "Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull"
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
return $callable($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
};
}
/**
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Middleware
/ValidatePostSize.php
class ValidatePostSize
{
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*
* @throws \Illuminate\Http\Exceptions\PostTooLargeException
*/
public function handle($request, Closure $next)
{
$max = $this->getPostMaxSize();
if ($max > 0 && $request->server('CONTENT_LENGTH') > $max) {
throw new PostTooLargeException;
}
return $next($request);
}
/**
* Determine the server 'post_max_size' as bytes.
*
* @return int
*/
protected function getPostMaxSize()
{
if (is_numeric($postMaxSize = ini_get('post_max_size'))) {
return (int) $postMaxSize;
}
$metric = strtoupper(substr($postMaxSize, -1));
$postMaxSize = (int) $postMaxSize;
switch ($metric) {
case 'K':
return $postMaxSize * 1024;
case 'M':
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
// the appropriate method and arguments, returning the results back out.
return $pipe($passable, $stack);
} elseif (! is_object($pipe)) {
[$name, $parameters] = $this->parsePipeString($pipe);
// If the pipe is a string we will parse the string and resolve the class out
// of the dependency injection container. We can then build a callable and
// execute the pipe function giving in the parameters that are required.
$pipe = $this->getContainer()->make($name);
$parameters = array_merge([$passable, $stack], $parameters);
} else {
// If the pipe is already an object we'll just make a callable and pass it to
// the pipe as-is. There is no need to do any extra parsing and formatting
// since the object we're given was already a fully instantiated object.
$parameters = [$passable, $stack];
}
$response = method_exists($pipe, $this->method)
? $pipe->{$this->method}(...$parameters)
: $pipe(...$parameters);
return $response instanceof Responsable
? $response->toResponse($this->container->make(Request::class))
: $response;
};
};
}
/**
* Parse full pipe string to get name and parameters.
*
* @param string $pipe
* @return array
*/
protected function parsePipeString($pipe)
{
[$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, []);
if (is_string($parameters)) {
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
Closure {#665
class: "Illuminate\Routing\Pipeline"
this: Pipeline {#30 …}
parameters: {
$passable: {}
}
use: {
$stack: Closure {#664 …}
$pipe: "App\Http\Middleware\TrimStrings"
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
return $callable($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
};
}
/**
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Middleware
/CheckForMaintenanceMode.php
*
* @throws \Symfony\Component\HttpKernel\Exception\HttpException
*/
public function handle($request, Closure $next)
{
if ($this->app->isDownForMaintenance()) {
$data = json_decode(file_get_contents($this->app->storagePath().'/framework/down'), true);
if (isset($data['allowed']) && IpUtils::checkIp($request->ip(), (array) $data['allowed'])) {
return $next($request);
}
if ($this->inExceptArray($request)) {
return $next($request);
}
throw new MaintenanceModeException($data['time'], $data['retry'], $data['message']);
}
return $next($request);
}
/**
* Determine if the request has a URI that should be accessible in maintenance mode.
*
* @param \Illuminate\Http\Request $request
* @return bool
*/
protected function inExceptArray($request)
{
foreach ($this->except as $except) {
if ($except !== '/') {
$except = trim($except, '/');
}
if ($request->fullUrlIs($except) || $request->is($except)) {
return true;
}
}
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
// the appropriate method and arguments, returning the results back out.
return $pipe($passable, $stack);
} elseif (! is_object($pipe)) {
[$name, $parameters] = $this->parsePipeString($pipe);
// If the pipe is a string we will parse the string and resolve the class out
// of the dependency injection container. We can then build a callable and
// execute the pipe function giving in the parameters that are required.
$pipe = $this->getContainer()->make($name);
$parameters = array_merge([$passable, $stack], $parameters);
} else {
// If the pipe is already an object we'll just make a callable and pass it to
// the pipe as-is. There is no need to do any extra parsing and formatting
// since the object we're given was already a fully instantiated object.
$parameters = [$passable, $stack];
}
$response = method_exists($pipe, $this->method)
? $pipe->{$this->method}(...$parameters)
: $pipe(...$parameters);
return $response instanceof Responsable
? $response->toResponse($this->container->make(Request::class))
: $response;
};
};
}
/**
* Parse full pipe string to get name and parameters.
*
* @param string $pipe
* @return array
*/
protected function parsePipeString($pipe)
{
[$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, []);
if (is_string($parameters)) {
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
Closure {#666
class: "Illuminate\Routing\Pipeline"
this: Pipeline {#30 …}
parameters: {
$passable: {}
}
use: {
$stack: Closure {#665 …}
$pipe: "Illuminate\Foundation\Http\Middleware\ValidatePostSize"
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Routing
/Pipeline.php
return $this->handleException($passable, new FatalThrowableError($e));
}
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function carry()
{
return function ($stack, $pipe) {
return function ($passable) use ($stack, $pipe) {
try {
$slice = parent::carry();
$callable = $slice($stack, $pipe);
return $callable($passable);
} catch (Exception $e) {
return $this->handleException($passable, $e);
} catch (Throwable $e) {
return $this->handleException($passable, new FatalThrowableError($e));
}
};
};
}
/**
* Handle the given exception.
*
* @param mixed $passable
* @param \Exception $e
* @return mixed
*
* @throws \Exception
*/
protected function handleException($passable, Exception $e)
{
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Pipeline
/Pipeline.php
public function via($method)
{
$this->method = $method;
return $this;
}
/**
* Run the pipeline with a final destination callback.
*
* @param \Closure $destination
* @return mixed
*/
public function then(Closure $destination)
{
$pipeline = array_reduce(
array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
);
return $pipeline($this->passable);
}
/**
* Get the final piece of the Closure onion.
*
* @param \Closure $destination
* @return \Closure
*/
protected function prepareDestination(Closure $destination)
{
return function ($passable) use ($destination) {
return $destination($passable);
};
}
/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Kernel.php
}
/**
* Send the given request through the middleware / router.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\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());
}
/**
* Bootstrap the application for HTTP requests.
*
* @return void
*/
public function bootstrap()
{
if (! $this->app->hasBeenBootstrapped()) {
$this->app->bootstrapWith($this->bootstrappers());
}
}
/**
* Get the route dispatcher callback.
*
* @return \Closure
*/
protected function dispatchToRouter()
Arguments
Closure {#22
class: "Illuminate\Foundation\Http\Kernel"
this: Kernel {#29 …}
parameters: {
$request: {}
}
}
/var
/www
/goodschool
/campus
/casyymps-demo
/vendor
/laravel
/framework
/src
/Illuminate
/Foundation
/Http
/Kernel.php
$router->middlewareGroup($key, $middleware);
}
foreach ($this->routeMiddleware as $key => $middleware) {
$router->aliasMiddleware($key, $middleware);
}
}
/**
* Handle an incoming HTTP request.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
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']->dispatch(
new Events\RequestHandled($request, $response)
);
return $response;
}
/**
* Send the given request through the middleware / router.
*
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}
/var
/www
/goodschool
/campus
/casyymps-demo
/public
/index.php
*/
$app = require_once __DIR__.'/../bootstrap/app.php';
/*
|--------------------------------------------------------------------------
| Run The Application
|--------------------------------------------------------------------------
|
| Once we have the application, we can handle the incoming request
| through the kernel, and send the associated response back to
| the client's browser allowing them to enjoy the creative
| and wonderful application we have prepared for them.
|
*/
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);
$response->send();
$kernel->terminate($request, $response);
Arguments
Request {#42
#json: null
#convertedFiles: null
#userResolver: Closure {#683
class: "Illuminate\Auth\AuthServiceProvider"
this: AuthServiceProvider {#41 …}
parameters: {
$guard: {
default: null
}
}
use: {
$app: Application {#2 …}
}
}
#routeResolver: null
+attributes: ParameterBag {#44}
+request: ParameterBag {#50}
+query: ParameterBag {#50}
+server: ServerBag {#46}
+files: FileBag {#47}
+cookies: ParameterBag {#45}
+headers: HeaderBag {#48}
#content: null
#languages: null
#charsets: null
#encodings: null
#acceptableContentTypes: array:1 [
0 => "*/*"
]
#pathInfo: "/it-school/php/webcms/public/index.php3"
#requestUri: "/it-school/php/webcms/public/index.php3?refid=550&mode=published&nocache1591464670"
#baseUrl: ""
#basePath: null
#method: "GET"
#format: null
#session: null
#locale: null
#defaultLocale: "en"
-isHostValid: true
-isForwardedValid: true
basePath: ""
format: "html"
}