Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Support\Slim;

use Clockwork\Clockwork;

use Clockwork\Authentication\NullAuthenticator;

use Clockwork\DataSource\PsrMessageDataSource;

use Clockwork\Storage\FileStorage;

use Clockwork\Helpers\ServerTiming;

use Psr\Http\Message\ServerRequestInterface as Request;

use Psr\Http\Server\RequestHandlerInterface as RequestHandler;

// Slim 4 middleware

class ClockworkMiddleware

{

	protected $app;

	protected $clockwork;

	protected $startTime;

	public function __construct($app, $storagePathOrClockwork, $startTime = null)

	{

		$this->app = $app;

		$this->clockwork = $storagePathOrClockwork instanceof Clockwork

			? $storagePathOrClockwork : $this->createDefaultClockwork($storagePathOrClockwork);

		$this->startTime = $startTime ?: microtime(true);

	}

	public function __invoke(Request $request, RequestHandler $handler)

	{

		return $this->process($request, $handler);

	}

	public function process(Request $request, RequestHandler $handler)

	{

		$authUri = '#/__clockwork/auth#';

		if (preg_match($authUri, $request->getUri()->getPath(), $matches)) {

			return $this->authenticate($request);

		}

		$clockworkDataUri = '#/__clockwork(?:/(?<id>[0-9-]+))?(?:/(?<direction>(?:previous|next)))?(?:/(?<count>\d+))?#';

		if (preg_match($clockworkDataUri, $request->getUri()->getPath(), $matches)) {

			$matches = array_merge([ 'id' => null, 'direction' => null, 'count' => null ], $matches);

			return $this->retrieveRequest($request, $matches['id'], $matches['direction'], $matches['count']);

		}

		$response = $handler->handle($request);

		return $this->logRequest($request, $response);

	}

	protected function authenticate(Request $request)

	{

		$token = $this->clockwork->authenticator()->attempt($request->getParsedBody());

		return $this->jsonResponse([ 'token' => $token ], $token ? 200 : 403);

	}

	protected function retrieveRequest(Request $request, $id, $direction, $count)

	{

		$authenticator = $this->clockwork->authenticator();

		$storage = $this->clockwork->storage();

		$authenticated = $authenticator->check(current($request->getHeader('X-Clockwork-Auth')));

		if ($authenticated !== true) {

			return $this->jsonResponse([ 'message' => $authenticated, 'requires' => $authenticator->requires() ], 403);

		}

		if ($direction == 'previous') {

			$data = $storage->previous($id, $count);

		} elseif ($direction == 'next') {

			$data = $storage->next($id, $count);

		} elseif ($id == 'latest') {

			$data = $storage->latest();

		} else {

			$data = $storage->find($id);

		}

		return $this->jsonResponse($data);

	}

	protected function logRequest(Request $request, $response)

	{

		$this->clockwork->timeline()->finalize($this->startTime);

		$this->clockwork->addDataSource(new PsrMessageDataSource($request, $response));

		$this->clockwork->resolveRequest();

		$this->clockwork->storeRequest();

		$clockworkRequest = $this->clockwork->request();

		$response = $response

			->withHeader('X-Clockwork-Id', $clockworkRequest->id)

			->withHeader('X-Clockwork-Version', Clockwork::VERSION);

		if ($basePath = $this->app->getBasePath()) {

			$response = $response->withHeader('X-Clockwork-Path', $basePath);

		}

		return $response->withHeader('Server-Timing', ServerTiming::fromRequest($clockworkRequest)->value());

	}

	protected function createDefaultClockwork($storagePath)

	{

		$clockwork = new Clockwork();

		$clockwork->storage(new FileStorage($storagePath));

		$clockwork->authenticator(new NullAuthenticator);

		return $clockwork;

	}

	protected function jsonResponse($data, $status = 200)

	{

		$response = $this->app->getResponseFactory()

			->createResponse($status)

			->withHeader('Content-Type', 'application/json');

		$response->getBody()->write(json_encode($data));

		return $response;

	}

}