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 Laravel\Lumen\Application;

use Symfony\Component\HttpFoundation\Response;

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

class LumenDataSource extends DataSource

{

	// Lumen application instance

	protected $app;

	// Lumen response instance

	protected $response;

	// Whether we should collect log messages

	protected $collectLog = true;

	// Whether we should collect routes

	protected $collectRoutes = false;

	// Clockwork log instance

	protected $log;

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

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

	{

		$this->app = $app;

		$this->collectLog    = $collectLog;

		$this->collectRoutes = $collectRoutes;

		$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->uri            = $this->getRequestUri();

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

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

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

		$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 Lumen 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)) {

			// Lumen 5.4

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

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

			});

		} else {

			// Lumen 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 current route's controller

	protected function getController()

	{

		$routes = method_exists($this->app, 'getRoutes') ? $this->app->getRoutes() : [];

		$method = $this->getRequestMethod();

		$pathInfo = $this->getPathInfo();

		if (isset($routes[$method.$pathInfo]['action']['uses'])) {

			$controller = $routes[$method.$pathInfo]['action']['uses'];

		} elseif (isset($routes[$method.$pathInfo]['action'][0])) {

			$controller = $routes[$method.$pathInfo]['action'][0];

		} else {

			$controller = null;

		}

		if ($controller instanceof \Closure) {

			$controller = 'anonymous function';

		} elseif (is_object($controller)) {

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

		} 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()

	{

		if ($this->app->bound('request')) {

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

		} elseif (isset($_POST['_method'])) {

			return strtoupper($_POST['_method']);

		} else {

			return $_SERVER['REQUEST_METHOD'];

		}

	}

	// 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 application routes

	protected function getRoutes()

	{

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

		if (isset($this->app->router)) {

			$routes = array_values($this->app->router->getRoutes());

		} elseif (method_exists($this->app, 'getRoutes')) {

			$routes = array_values($this->app->getRoutes());

		} else {

			$routes = [];

		}

		return array_map(function ($route) {

			return [

				'method' => $route['method'],

				'uri'    => $route['uri'],

				'name'   => isset($route['action']['as']) ? $route['action']['as'] : null,

				'action' => isset($route['action']['uses']) && is_string($route['action']['uses']) ? $route['action']['uses'] : 'anonymous function',

				'middleware' => isset($route['action']['middleware']) ? $route['action']['middleware'] : null,

			];

		}, $routes);

	}

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

	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 (! isset($user->email) || ! isset($user->id)) return;

		$request->setAuthenticatedUser($user->email, $user->id, [

			'email' => $user->email,

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

		]);

	}

	// Get the request path info

	protected function getPathInfo()

	{

		if ($this->app->bound('request')) {

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

		} else {

			$query = isset($_SERVER['QUERY_STRING']) ? $_SERVER['QUERY_STRING'] : '';

			return '/' . trim(str_replace("?{$query}", '', $_SERVER['REQUEST_URI']), '/');

		}

	}

}