Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Support\Laravel;

use Clockwork\Clockwork;
use Clockwork\Authentication\AuthenticatorInterface;
use Clockwork\DataSource\EloquentDataSource;
use Clockwork\DataSource\LaravelCacheDataSource;
use Clockwork\DataSource\LaravelDataSource;
use Clockwork\DataSource\LaravelEventsDataSource;
use Clockwork\DataSource\LaravelNotificationsDataSource;
use Clockwork\DataSource\LaravelQueueDataSource;
use Clockwork\DataSource\LaravelRedisDataSource;
use Clockwork\DataSource\LaravelTwigDataSource;
use Clockwork\DataSource\LaravelViewsDataSource;
use Clockwork\DataSource\SwiftDataSource;
use Clockwork\DataSource\TwigDataSource;
use Clockwork\DataSource\XdebugDataSource;
use Clockwork\Helpers\StackFilter;
use Clockwork\Request\Request;
use Clockwork\Storage\StorageInterface;

use Illuminate\Support\ServiceProvider;

class ClockworkServiceProvider extends ServiceProvider
{
        public function boot()
        {
                if ($this->app['clockwork.support']->isCollectingData()) {
                        $this->registerEventListeners();
                        $this->registerMiddleware();
                }

                $this->app['clockwork.support']->handleArtisanEvents();
                $this->app['clockwork.support']->handleOctaneEvents();

                // If Clockwork is disabled, return before registering middleware or routes
                if (! $this->app['clockwork.support']->isEnabled()) return;

                $this->registerRoutes();

                // register the Clockwork Web UI routes
                if ($this->app['clockwork.support']->isWebEnabled()) {
                        $this->registerWebRoutes();
                }
        }

        public function register()
        {
                $this->registerConfiguration();
                $this->registerClockwork();
                $this->registerCommands();
                $this->registerDataSources();
                $this->registerAliases();

                $this->app->make('clockwork.request'); // instantiate the request to have id and time available as early as possible

                $this->app['clockwork.support']
                        ->configureSerializer()
                        ->configureShouldCollect()
                        ->configureShouldRecord();

                if ($this->app['clockwork.support']->getConfig('register_helpers', true)) {
                        require __DIR__ . '/helpers.php';
                }
        }

        // Register the configuration file
        protected function registerConfiguration()
        {
                $this->publishes([ __DIR__ . '/config/clockwork.php' => config_path('clockwork.php') ]);
                $this->mergeConfigFrom(__DIR__ . '/config/clockwork.php', 'clockwork');
        }

        // Register core Clockwork components
        protected function registerClockwork()
        {
                $this->app->singleton('clockwork', function ($app) {
                        return (new Clockwork)
                                ->authenticator($app['clockwork.authenticator'])
                                ->request($app['clockwork.request'])
                                ->storage($app['clockwork.storage']);
                });

                $this->app->singleton('clockwork.authenticator', function ($app) {
                        return $app['clockwork.support']->makeAuthenticator();
                });

                $this->app->singleton('clockwork.request', function ($app) {
                        return new Request;
                });

                $this->app->singleton('clockwork.storage', function ($app) {
                        return $app['clockwork.support']->makeStorage();
                });

                $this->app->singleton('clockwork.support', function ($app) {
                        return new ClockworkSupport($app);
                });
        }

        // Register the artisan commands
        protected function registerCommands()
        {
                $this->commands([
                        ClockworkCleanCommand::class
                ]);
        }

        // Register Clockwork data sources
        protected function registerDataSources()
        {
                $this->app->singleton('clockwork.cache', function ($app) {
                        return (new LaravelCacheDataSource(
                                $app['events'],
                                $app['clockwork.support']->getConfig('features.cache.collect_queries'),
                                $app['clockwork.support']->getConfig('features.cache.collect_values')
                        ));
                });

                $this->app->singleton('clockwork.eloquent', function ($app) {
                        $dataSource = (new EloquentDataSource(
                                $app['db'],
                                $app['events'],
                                $app['clockwork.support']->getConfig('features.database.collect_queries'),
                                $app['clockwork.support']->getConfig('features.database.slow_threshold'),
                                $app['clockwork.support']->getConfig('features.database.slow_only'),
                                $app['clockwork.support']->getConfig('features.database.detect_duplicate_queries'),
                                $app['clockwork.support']->getConfig('features.database.collect_models_actions'),
                                $app['clockwork.support']->getConfig('features.database.collect_models_retrieved')
                        ));

                        // if we are collecting queue jobs, filter out queries caused by the database queue implementation
                        if ($app['clockwork.support']->isCollectingQueueJobs()) {
                                $dataSource->addFilter(function ($query, $trace) {
                                        return ! $trace->first(StackFilter::make()->isClass(\Illuminate\Queue\DatabaseQueue::class));
                                }, 'early');
                        }

                        if ($app->runningUnitTests()) {
                                $dataSource->addFilter(function ($query, $trace) {
                                        return ! $trace->first(StackFilter::make()->isClass([
                                                \Illuminate\Database\Migrations\Migrator::class,
                                                \Illuminate\Database\Console\Migrations\MigrateCommand::class
                                        ]));
                                });
                        }

                        return $dataSource;
                });

                $this->app->singleton('clockwork.events', function ($app) {
                        return (new LaravelEventsDataSource(
                                $app['events'],
                                $app['clockwork.support']->getConfig('features.events.ignored_events', [])
                        ));
                });

                $this->app->singleton('clockwork.laravel', function ($app) {
                        return (new LaravelDataSource(
                                $app,
                                $app['clockwork.support']->isFeatureEnabled('log'),
                                $app['clockwork.support']->isFeatureEnabled('routes'),
                                $app['clockwork.support']->getConfig('features.routes.only_namespaces', [])
                        ));
                });

                $this->app->singleton('clockwork.notifications', function ($app) {
                        return new LaravelNotificationsDataSource($app['events']);
                });

                $this->app->singleton('clockwork.queue', function ($app) {
                        return (new LaravelQueueDataSource($app['queue']->connection()));
                });

                $this->app->singleton('clockwork.redis', function ($app) {
                        $dataSource = new LaravelRedisDataSource($app['events']);

                        // if we are collecting queue jobs, filter out commands executed by the redis queue implementation
                        if ($app['clockwork.support']->isCollectingQueueJobs()) {
                                $dataSource->addFilter(function ($query, $trace) {
                                        return ! $trace->first(StackFilter::make()->isClass([
                                                \Illuminate\Queue\RedisQueue::class,
                                                \Laravel\Horizon\Repositories\RedisJobRepository::class,
                                                \Laravel\Horizon\Repositories\RedisTagRepository::class,
                                                \Laravel\Horizon\Repositories\RedisMetricsRepository::class
                                        ]));
                                });
                        }

                        return $dataSource;
                });

                $this->app->singleton('clockwork.swift', function ($app) {
                        return new SwiftDataSource($app['mailer']->getSwiftMailer());
                });

                $this->app->singleton('clockwork.twig', function ($app) {
                        return new TwigDataSource($app['twig']);
                });

                $this->app->singleton('clockwork.views', function ($app) {
                        return new LaravelViewsDataSource(
                                $app['events'],
                                $app['clockwork.support']->getConfig('features.views.collect_data')
                        );
                });

                $this->app->singleton('clockwork.xdebug', function ($app) {
                        return new XdebugDataSource;
                });
        }

        // Set up aliases for all Clockwork parts so they can be resolved by type-hinting
        protected function registerAliases()
        {
                $this->app->alias('clockwork', Clockwork::class);

                $this->app->alias('clockwork.authenticator', AuthenticatorInterface::class);
                $this->app->alias('clockwork.storage', StorageInterface::class);
                $this->app->alias('clockwork.support', ClockworkSupport::class);

                $this->app->alias('clockwork.cache', LaravelCacheDataSource::class);
                $this->app->alias('clockwork.eloquent', EloquentDataSource::class);
                $this->app->alias('clockwork.events', LaravelEventsDataSource::class);
                $this->app->alias('clockwork.laravel', LaravelDataSource::class);
                $this->app->alias('clockwork.notifications', LaravelNotificationsDataSource::class);
                $this->app->alias('clockwork.queue', LaravelQueueDataSource::class);
                $this->app->alias('clockwork.redis', LaravelRedisDataSource::class);
                $this->app->alias('clockwork.swift', SwiftDataSource::class);
                $this->app->alias('clockwork.xdebug', XdebugDataSource::class);
        }

        // Register event listeners
        protected function registerEventListeners()
        {
                $this->app->booted(function () {
                        $this->app['clockwork.support']->addDataSources()->listenToEvents();
                });
        }

        // Register middleware
        protected function registerMiddleware()
        {
                $kernel = $this->app[\Illuminate\Contracts\Http\Kernel::class];

                if (method_exists($kernel, 'hasMiddleware') && $kernel->hasMiddleware(ClockworkMiddleware::class)) return;

                $kernel->prependMiddleware(ClockworkMiddleware::class);
        }

        protected function registerRoutes()
        {
                $this->app['router']->get('/__clockwork/{id}/extended', 'Clockwork\Support\Laravel\ClockworkController@getExtendedData')
                        ->where('id', '([0-9-]+|latest)');
                $this->app['router']->get('/__clockwork/{id}/{direction?}/{count?}', 'Clockwork\Support\Laravel\ClockworkController@getData')
                        ->where('id', '([0-9-]+|latest)')->where('direction', '(next|previous)')->where('count', '\d+');
                $this->app['router']->put('/__clockwork/{id}', 'Clockwork\Support\Laravel\ClockworkController@updateData');
                $this->app['router']->post('/__clockwork/auth', 'Clockwork\Support\Laravel\ClockworkController@authenticate');
        }

        protected function registerWebRoutes()
        {
                $this->app['clockwork.support']->webPaths()->each(function ($path) {
                        $this->app['router']->get("{$path}", 'Clockwork\Support\Laravel\ClockworkController@webRedirect');
                        $this->app['router']->get("{$path}/app", 'Clockwork\Support\Laravel\ClockworkController@webIndex');
                        $this->app['router']->get("{$path}/{path}", 'Clockwork\Support\Laravel\ClockworkController@webAsset')
                                ->where('path', '.+');
                });
        }

        public function provides()
        {
                return [ 'clockwork' ];
        }
}