Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\DataSource;

use Clockwork\DataSource\DataSource;

use Clockwork\Helpers\Serializer;

use Clockwork\Request\Log;

use Clockwork\Request\Request;

use Illuminate\Contracts\Foundation\Application;

use Symfony\Component\HttpFoundation\Response;

// Data source for Laravel framework, provides application log, request and response information

class LaravelDataSource extends DataSource

{

	// Laravel application instance

	protected $app;

	// Laravel response instance

	protected $response;

	// Whether we should collect log messages

	protected $collectLog = true;

	// Whether we should collect routes

	protected $collectRoutes = false;

	// Only collect routes from following list of namespaces (collect all if empty)

	protected $routesOnlyNamespaces = [];

	// Clockwork log instance

	protected $log;

	// Create a new data source, takes Laravel application instance and additional options as an arguments

	public function __construct(Application $app, $collectLog = true, $collectRoutes = false, $routesOnlyNamespaces = true)

	{

		$this->app = $app;

		$this->collectLog           = $collectLog;

		$this->collectRoutes        = $collectRoutes;

		$this->routesOnlyNamespaces = $routesOnlyNamespaces;

		$this->log = new Log;

	}

	// Adds request, response information, middleware, routes, session data, user and log entries to the request

	public function resolve(Request $request)

	{

		$request->method         = $this->getRequestMethod();

		$request->url            = $this->getRequestUrl();

		$request->uri            = $this->getRequestUri();

		$request->controller     = $this->getController();

		$request->headers        = $this->getRequestHeaders();

		$request->responseStatus = $this->getResponseStatus();

		$request->middleware     = $this->getMiddleware();

		$request->routes         = $this->getRoutes();

		$request->sessionData    = $this->getSessionData();

		$this->resolveAuthenticatedUser($request);

		$request->log()->merge($this->log);

		return $request;

	}

	// Reset the data source to an empty state, clearing any collected data

	public function reset()

	{

		$this->log = new Log;

	}

	// Set Laravel application instance for the current request

	public function setApplication(Application $app)

	{

		$this->app = $app;

		return $this;

	}

	// Set Laravel response instance for the current request

	public function setResponse(Response $response)

	{

		$this->response = $response;

		return $this;

	}

	// Listen for the log events

	public function listenToEvents()

	{

		if (! $this->collectLog) return;

		if (class_exists(\Illuminate\Log\Events\MessageLogged::class)) {

			// Laravel 5.4

			$this->app['events']->listen(\Illuminate\Log\Events\MessageLogged::class, function ($event) {

				$this->log->log($event->level, $event->message, $event->context);

			});

		} else {

			// Laravel 5.0 to 5.3

			$this->app['events']->listen('illuminate.log', function ($level, $message, $context) {

				$this->log->log($level, $message, $context);

			});

		}

	}

	// Get a textual representation of the current route's controller

	protected function getController()

	{

		$router = $this->app['router'];

		$route = $router->current();

		$controller = $route ? $route->getActionName() : null;

		if ($controller instanceof \Closure) {

			$controller = 'anonymous function';

		} elseif (is_object($controller)) {

			$controller = 'instance of ' . get_class($controller);

		} elseif (is_array($controller) && count($controller) == 2) {

			if (is_object($controller[0])) {

				$controller = get_class($controller[0]) . '->' . $controller[1];

			} else {

				$controller = $controller[0] . '::' . $controller[1];

			}

		} elseif (! is_string($controller)) {

			$controller = null;

		}

		return $controller;

	}

	// Get the request headers

	protected function getRequestHeaders()

	{

		return $this->app['request']->headers->all();

	}

	// Get the request method

	protected function getRequestMethod()

	{

		return $this->app['request']->getMethod();

	}

	// Get the request URL

	protected function getRequestUrl()

	{

		return $this->app['request']->fullUrl();

	}

	// Get the request URI

	protected function getRequestUri()

	{

		return $this->app['request']->getRequestUri();

	}

	// Get the response status code

	protected function getResponseStatus()

	{

		return $this->response ? $this->response->getStatusCode() : null;

	}

	// Get an array of middleware for the matched route

	protected function getMiddleware()

	{

		$route = $this->app['router']->current();

		if (! $route) return;

		return method_exists($route, 'gatherMiddleware') ? $route->gatherMiddleware() : $route->middleware();

	}

	// Get an array of application routes

	protected function getRoutes()

	{

		if (! $this->collectRoutes) return [];

		return array_values(array_filter(array_map(function ($route) {

			$action = $route->getActionName() ?: 'anonymous function';

			$namespace = strpos($action, '\\') !== false ? explode('\\', $action)[0] : null;

			if (count($this->routesOnlyNamespaces) && ! in_array($namespace, $this->routesOnlyNamespaces)) return;

			return [

				'method'     => implode(', ', $route->methods()),

				'uri'        => $route->uri(),

				'name'       => $route->getName(),

				'action'     => $action,

				'middleware' => $route->middleware(),

				'before'     => method_exists($route, 'beforeFilters') ? implode(', ', array_keys($route->beforeFilters())) : '',

				'after'      => method_exists($route, 'afterFilters') ? implode(', ', array_keys($route->afterFilters())) : ''

			];

		}, $this->app['router']->getRoutes()->getRoutes())));

	}

	// Get the session data (normalized with removed passwords)

	protected function getSessionData()

	{

		if (! isset($this->app['session'])) return [];

		return $this->removePasswords((new Serializer)->normalizeEach($this->app['session']->all()));

	}

	// Add authenticated user data to the request

	protected function resolveAuthenticatedUser(Request $request)

	{

		if (! isset($this->app['auth'])) return;

		if (! ($user = $this->app['auth']->user())) return;

		if ($user instanceof \Illuminate\Database\Eloquent\Model) {

			// retrieve attributes in this awkward way to make sure we don't trigger exceptions with Eloquent strict mode on

			$keyName = method_exists($user, 'getAuthIdentifierName') ? $user->getAuthIdentifierName() : $user->getKeyName();

			$user = $user->getAttributes();

			$userId = isset($user[$keyName]) ? $user[$keyName] : null;

			$userEmail = isset($user['email']) ? $user['email'] : $userId;

			$userName = isset($user['name']) ? $user['name'] : null;

		} else {

			$userId = $user->getAuthIdentifier();

			$userEmail = isset($user->email) ? $user->email : $userId;

			$userName = isset($user->name) ? $user->name : null;

		}

		$request->setAuthenticatedUser($userEmail, $userId, [

			'email' => $userEmail,

			'name'  => $userName

		]);

	}

}