Register a account management interface instance.

@return void
557882
protected function registerAccountManagementInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Services\AccountManagement\AccountManagementInterface', function($app)
		{
			return new AccountManager(
				$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
				$app->make('App\Kwaai\Security\Services\JournalManagement\JournalManagementInterface'),
				$app->make('App\Kwaai\Security\Repositories\Journal\JournalInterface'),
				new	\Mgallegos\LaravelJqgrid\Encoders\JqGridJsonEncoder($app->make('excel')),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\Account\EloquentAccountGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\Account\AccountInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\AccountType\AccountTypeInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\JournalEntryInterface'),
				new Carbon(),
				$app['db'],
				$app['translator'],
				$app['config']
			);
		});
	}
954835
public function register()
    {
        $this->app->singleton('Congraph\Core\Bus\CommandDispatcher', function ($app) {
            return new CommandDispatcher($app, function () use ($app) {
                return $app['Illuminate\Contracts\Queue\Queue'];
            });
        });

        $this->app->alias(
            'Congraph\Core\Bus\CommandDispatcher', 'Illuminate\Contracts\Bus\Dispatcher'
        );

        $this->app->alias(
            'Congraph\Core\Bus\CommandDispatcher', 'Illuminate\Contracts\Bus\QueueingDispatcher'
        );
    }
317125
public function register()
    {
        // Bind the user resolver instance into the IoC.
        $this->app->bind(ResolverInterface::class, function () {
            return new UserResolver(
                $this->app->make(AdldapInterface::class)
            );
        });

        // Here we will register the event listener that will bind the users LDAP
        // model to their Eloquent model upon authentication (if configured).
        // This allows us to utilize their LDAP model right
        // after authentication has passed.
        Event::listen([Login::class, Authenticated::class], Listeners\BindsLdapUserModel::class);

        if ($this->isLogging()) {
            // If logging is enabled, we will set up our event listeners that
            // log each event fired throughout the authentication process.
            foreach ($this->getLoggingEvents() as $event => $listener) {
                Event::listen($event, $listener);
            }
        }
    }
324364
public function register()
    {
        // Merge Configuration
        $this->mergeConfigFrom(__DIR__ . '/../config/membership.php', 'membership');

        // Register the Facade
        $this->app->bind('membership', function ($app) {
            return $app->make(Membership::class);
        });
        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();
            $loader->alias('Membership', MembershipFacade::class);
        });
    }
1126231
public function register()
    {
        $this->app->singleton('larinfo', function ($app) {
            $larinfo = new Larinfo(new Ipinfo(), new Request(), new Linfo(), new Manager());

            $token = config('services.ipinfo.token');

            if (! empty($token)) {
                return $larinfo->setIpinfoConfig($token);
            }

            $larinfo->setDatabaseConfig(config('database.connections.'.config('database.default')));

            return $larinfo;
        });
    }
390283
protected function registerApportionmentEntryInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Repositories\ApportionmentEntry\ApportionmentEntryInterface', function($app)
		{
			$AuthenticationManager = $app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface');

			return new \Mgallegos\DecimaAccounting\Accounting\Repositories\ApportionmentEntry\EloquentApportionmentEntry(new ApportionmentEntry(), $AuthenticationManager->getCurrentUserOrganizationConnection());
		});
	}
621618
public function register()
    {
        $this->registerRevisionRepository();
        $this->registerUserRepository();
        $this->registerGroupRepository();
        $this->registerCredentials();

        $this->registerLoginController();
        $this->registerRegistrationController();
        $this->registerResetController();
        $this->registerActivationController();
    }
1086179
protected function registerMigrationService(): void
    {
        $config = $this->app['config'];
        $config->set('database.migrations', $config->get('database.migrations') ?: 'migrations');
        $this->app->register(\Illuminate\Database\MigrationServiceProvider::class);

        $this->app->alias(
            'migration.repository',
            \Illuminate\Database\Migrations\MigrationRepositoryInterface::class
        );

        $this->app->singleton(
            'migrator',
            function ($app) {
                $repository = $app['migration.repository'];

                return new Migrator($repository, $app['db'], $app['files']);
            }
        );

        $this->app->alias(
            'migrator',
            \Illuminate\Database\Migrations\Migrator::class
        );
    }
703875
protected function registerManager()
    {
        $this->container->singleton('queue', function ($container) {
            // Once we have an instance of the queue manager, we will register the various
            // resolvers for the queue connectors. These connectors are responsible for
            // creating the classes that accept queue configs and instantiate queues.
            return tap(new QueueManager($container), function ($manager) {
                $this->registerConnectors($manager);
            });
        });
    }
495946
public function register()
    {
        // Configuring all guzzle clients.
        $this->app->bind(ClientInterface::class, function () {
            // Guzzle client
            return new Client(['handler' => $this->app->make(HandlerStack::class)]);
        });

        $this->app->alias(ClientInterface::class, Client::class);

        // Bind if needed.
        $this->app->bind(HandlerStack::class, function () {
            return HandlerStack::create();
        });

        // If resolved, by this SP or another, add some layers.
        $this->app->resolving(HandlerStack::class, function (HandlerStack $stack) {
            // We cannot log with debugbar from the CLI
            if ($this->app->runningInConsole()) {
                return;
            }
            
            /** @var \DebugBar\DebugBar $debugBar */
            $debugBar = $this->app->make('debugbar');

            $stack->push(new Middleware(new Profiler($timeline = $debugBar->getCollector('time'))));
            $stack->unshift(new ExceptionMiddleware($debugBar->getCollector('exceptions')));

            /** @var \GuzzleHttp\MessageFormatter $formatter */
            $formatter = $this->app->make(MessageFormatter::class);
            $stack->unshift(GuzzleMiddleware::log($debugBar->getCollector('messages'), $formatter));

            // Also log to the default PSR logger.
            if ($this->app->bound(LoggerInterface::class)) {
                $logger = $this->app->make(LoggerInterface::class);

                // Don't log to the same logger twice.
                if ($logger === $debugBar->getCollector('messages')) {
                    return;
                }

                // Push the middleware on the stack.
                $stack->unshift(GuzzleMiddleware::log($logger, $formatter));
            }
        });
    }
240533
public function register() {
        $this->commands([
            'Synga\PhpStormMeta\Laravel\Command\ExcludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\IncludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\GenerateCommand',
        ]);

        $this->app->singleton('Synga\InheritanceFinder\InheritanceFinderInterface', function(){
            if(!file_exists(storage_path('class_cache'))){
                mkdir(storage_path('class_cache'));
            }

            $config = new \Synga\InheritanceFinder\File\FileConfig();

            $config->setApplicationRoot(base_path());
            $config->setCacheDirectory(storage_path('class_cache'));

            return InheritanceFinderFactory::getInheritanceFinder($config);
        });
    }
504995
public function register()
    {
        $this->app->bind(TransactionRepositoryInterface::class, BalanceTransactionRepository::class);
        $this->app->bind(BalanceTransactionInterface::class, BalanceTransaction::class);
        $this->app->bind(BalanceServiceInterface::class, BalanceService::class);
    }
628591
public function register() {
		$this->files = new Filesystem;
		$this->registerScanCommand();

		$method = "singleton";
		// Bind the manager as a singleton on the container.
		$this->app->$method('permacon', function($app) {
			
			/**
			 * Construct the actual manager.
			 */
			return new Permacon($app);
		});
	}
795025
protected function registerAccessManager()
    {
        // Bind AccessManager.
        $this->app->singleton(AccessManager::SERVICE_ID, function (Application $app) {
            /** @var Repository $configRepo */
            $configRepo = $app->make('config');

            return new AccessManager(
                $configRepo->get('personality-insights.default_credentials'),
                $configRepo->get('personality-insights.api_version')
            );
        });
    }
133802
protected function registerCostCenterManagementInterface()
	{
		$this->app->bind('Mgallegos\DecimaAccounting\Accounting\Services\CostCenterManagement\CostCenterManagementInterface', function($app)
		{
			return new CostCenterManager(
				$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
				$app->make('App\Kwaai\Security\Services\JournalManagement\JournalManagementInterface'),
				$app->make('App\Kwaai\Security\Repositories\Journal\JournalInterface'),
				new	\Mgallegos\LaravelJqgrid\Encoders\JqGridJsonEncoder($app->make('excel')),
				new	\Mgallegos\DecimaAccounting\Accounting\Repositories\CostCenter\EloquentCostCenterGridRepository(
					$app['db'],
					$app->make('App\Kwaai\Security\Services\AuthenticationManagement\AuthenticationManagementInterface'),
					$app['translator']
				),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\CostCenter\CostCenterInterface'),
				$app->make('Mgallegos\DecimaAccounting\Accounting\Repositories\JournalEntry\JournalEntryInterface'),
				new Carbon(),
				$app['db'],
				$app['translator'],
				$app['config']
			);
		});
	}
737539
public function register()
    {
        // Handle case-insensitivity of interface names.
        $this->newInterfaces      = $this->arrayKeysToLowercase($this->newInterfaces);
        $this->unsupportedMethods = $this->arrayKeysToLowercase($this->unsupportedMethods);

        $targets = array(
            \T_CLASS,
            \T_FUNCTION,
            \T_CLOSURE,
        );

        if (\defined('T_ANON_CLASS')) {
            $targets[] = \T_ANON_CLASS;
        }

        if (\defined('T_RETURN_TYPE')) {
            $targets[] = \T_RETURN_TYPE;
        }

        return $targets;
    }
406236
public function register()
    {
        $this->app->singleton('validator/user/email', function (Application $app) {
            $config = $app->make('config');
            $manager = $app->make(ValidatorForSubjectInterface::class);

            $manager->setValidator(
                'unique_user_email',
                $app->make(
                    UniqueUserEmailValidator::class,
                    [
                        'testMXRecord' => $config->get('concrete.user.email.test_mx_record'),
                        'strict' => $config->get('concrete.user.email.strict'),
                    ]
                )
            );

            return $manager;
        });
    }