Set the connection resolver instance.
public static setConnectionResolver ( Illuminate\Database\ConnectionResolverInterface $resolver ) : void | ||
$resolver | Illuminate\Database\ConnectionResolverInterface | |
Résultat | void |
/** * Initialize the Laravel framework. * @param SymfonyRequest $request */ private function initialize($request = null) { // Store a reference to the database object // so the database connection can be reused during tests $oldDb = null; if ($this->app['db'] && $this->app['db']->connection()) { $oldDb = $this->app['db']; } // The module can login a user with the $I->amLoggedAs() method, // but this is not persisted between requests. Store a reference // to the logged in user to simulate this. $loggedInUser = null; if ($this->app['auth'] && $this->app['auth']->check()) { $loggedInUser = $this->app['auth']->user(); } // Load the application object $this->app = $this->kernel = $this->loadApplication(); // Set the request instance for the application if (is_null($request)) { $appConfig = (require $this->module->config['project_dir'] . 'config/app.php'); $request = SymfonyRequest::create($appConfig['url']); } $this->app->instance('request', Request::createFromBase($request)); $this->app->instance('middleware.disable', $this->module->config['disable_middleware']); // Bootstrap the application $this->app->make('Illuminate\\Contracts\\Http\\Kernel')->bootstrap(); // Restore the old database object if available if ($oldDb) { $this->app['db'] = $oldDb; Model::setConnectionResolver($this->app['db']); } // If there was a user logged in restore this user. // Also reload the user object from the user provider to prevent stale user data. if ($loggedInUser) { $refreshed = $this->app['auth']->getProvider()->retrieveById($loggedInUser->getAuthIdentifier()); $this->app['auth']->setUser($refreshed ?: $loggedInUser); } $this->module->setApplication($this->app); }
/** * Initialize the Laravel framework. */ private function initialize() { // Store a reference to the database object // so the database connection can be reused during tests $oldDb = null; if ($this->app['db'] && $this->app['db']->connection()) { $oldDb = $this->app['db']; } // The module can login a user with the $I->amLoggedAs() method, // but this is not persisted between requests. Store a reference // to the logged in user to simulate this. $loggedInUser = null; if ($this->app['auth'] && $this->app['auth']->check()) { $loggedInUser = $this->app['auth']->user(); } $this->app = $this->kernel = $this->loadApplication(); $this->app->make('Illuminate\\Contracts\\Http\\Kernel')->bootstrap(); // Set the base url for the Request object $url = $this->app['config']->get('app.url', 'http://localhost'); $this->app->instance('request', Request::createFromBase(SymfonyRequest::create($url))); if ($oldDb) { $this->app['db'] = $oldDb; Model::setConnectionResolver($this->app['db']); } // If there was a user logged in restore this user. // Also reload the user object from the user provider to prevent stale user data. if ($loggedInUser) { $refreshed = $this->app['auth']->getProvider()->retrieveById($loggedInUser->getAuthIdentifier()); $this->app['auth']->setUser($refreshed ?: $loggedInUser); } $this->module->setApplication($this->app); }
private function setDatabase($dbConfig) { $capsule = new Capsule(); $capsule->addConnection($dbConfig, $this->connName); $this->set('db', $capsule->getConnection($this->connName)); //set model conn for all models $resolver = new \Illuminate\Database\ConnectionResolver(); $resolver->addConnection($this->connName, $capsule->getConnection($this->connName)); $resolver->setDefaultConnection($this->connName); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); }
protected function __construct() { $this->app = new Container(); // Register mock instances with IoC container $config = $this->getConfig(); $this->app->singleton('config', function () use($config) { return $config; }); list($connector, $manager) = $this->getDatabase(); $this->app->singleton('db.factory', function () use($connector) { return $connector; }); $this->app->singleton('db', function () use($manager) { return $manager; }); $auth = $this->getAuth(); $this->app->singleton('auth', function () use($auth) { return $auth; }); $dispatcher = new Dispatcher($this->app); $this->app->singleton('events', function () use($dispatcher) { return $dispatcher; }); Model::setConnectionResolver($this->app['db']); Model::setEventDispatcher($this->app['events']); }
/** * Initialize the Laravel Framework. * * @throws ModuleConfig */ private function initialize() { // Store a reference to the database object // so the database connection can be reused during tests $oldDb = null; if ($this->app['db'] && $this->app['db']->connection()) { $oldDb = $this->app['db']; } // Store the current value for the router filters // so it can be reset after reloading the application $oldFiltersEnabled = null; if ($router = $this->app['router']) { $property = new \ReflectionProperty(get_class($router), 'filtering'); $property->setAccessible(true); $oldFiltersEnabled = $property->getValue($router); } $this->app = $this->loadApplication(); $this->kernel = $this->getStackedClient(); $this->app->boot(); // Reset the booted flag of the Application object // so the app will be booted again if it receives a new Request $property = new \ReflectionProperty(get_class($this->app), 'booted'); $property->setAccessible(true); $property->setValue($this->app, false); if ($oldDb) { $this->app['db'] = $oldDb; Model::setConnectionResolver($this->app['db']); } if (!is_null($oldFiltersEnabled)) { $oldFiltersEnabled ? $this->app['router']->enableFilters() : $this->app['router']->disableFilters(); } $this->module->setApplication($this->app); }
/** * Creates a new instance of Sentry. * * @return \Cartalyst\Sentry\Sentry * @throws \RuntimeException */ public static function createSentry() { // Get some resources $ci =& get_instance(); $ci->load->driver('session'); // If Eloquent doesn't exist, then we must assume they are using their own providers. if (class_exists('Illuminate\\Database\\Eloquent\\Model')) { $ci->load->database(); // Let's connect and get the PDO instance $method = $ci->db->pconnect ? 'db_pconnect' : 'db_connect'; $pdo = $ci->db->{$method}(); // Validate PDO if (!$pdo instanceof PDO) { throw new \RuntimeException("Sentry will only work with PDO database connections."); } // Setup PDO foreach (static::$pdoOptions as $key => $value) { $pdo->setAttribute($key, $value); } $driverName = $pdo->getAttribute(PDO::ATTR_DRIVER_NAME); $tablePrefix = substr($ci->db->dbprefix('.'), 0, -1); Eloquent::setConnectionResolver(new ConnectionResolver($pdo, $driverName, $tablePrefix)); } return new BaseSentry($userProvider = new UserProvider(new NativeHasher()), new GroupProvider(), new ThrottleProvider($userProvider), new CISession($ci->session), new CICookie($ci->input), $ci->input->ip_address()); }
/** * @param $resolver */ protected function bootModels($resolver) { Model::clearBootedModels(); Model::setEventDispatcher($this->app['illuminate.events']); Model::setConnectionResolver($resolver); $this->app['dispatcher']->dispatch(NineEvents::MODELS_BOOTED, new EloquentEvent($this->container->get('db'))); }
/** * Register the service provider. * * @return void */ public function register() { $this->app->singleton('flarum.db', function () { $factory = new ConnectionFactory($this->app); $connection = $factory->make($this->app->make('flarum.config')['database']); $connection->setEventDispatcher($this->app->make('Illuminate\\Contracts\\Events\\Dispatcher')); $connection->setFetchMode(PDO::FETCH_CLASS); return $connection; }); $this->app->alias('flarum.db', 'Illuminate\\Database\\ConnectionInterface'); $this->app->singleton('Illuminate\\Database\\ConnectionResolverInterface', function () { $resolver = new ConnectionResolver(['flarum' => $this->app->make('flarum.db')]); $resolver->setDefaultConnection('flarum'); return $resolver; }); $this->app->alias('Illuminate\\Database\\ConnectionResolverInterface', 'db'); if (Core::isInstalled()) { $this->app->booting(function () { $resolver = $this->app->make('Illuminate\\Database\\ConnectionResolverInterface'); Model::setConnectionResolver($resolver); Model::setEventDispatcher($this->app->make('events')); }); } $this->app->singleton('Flarum\\Migrations\\MigrationRepositoryInterface', function ($app) { return new DatabaseMigrationRepository($app['db'], 'migrations'); }); }
/** * Set mock connection. * * @param \Illuminate\Database\Eloquent\Model $model */ protected function addMockConnection(Model $model) { $resolver = m::mock('\\Illuminate\\Database\\ConnectionResolverInterface'); $model->setConnectionResolver($resolver); $resolver->shouldReceive('connection')->andReturn(m::mock('\\Illuminate\\Database\\Connection')); $model->getConnection()->shouldReceive('getQueryGrammar')->andReturn(m::mock('\\Illuminate\\Database\\Query\\Grammars\\Grammar')); $model->getConnection()->shouldReceive('getPostProcessor')->andReturn(m::mock('\\Illuminate\\Database\\Query\\Processors\\Processor')); }
public function __construct() { $settings = array('driver' => 'pgsql', 'host' => 'localhost', 'database' => 'yesbike', 'username' => 'postgres', 'password' => 'macedo', 'charset' => 'UTF8', 'prefix' => ''); $connFactory = new \Illuminate\Database\Connectors\ConnectionFactory(new \Illuminate\Container\Container()); $conn = $connFactory->make($settings); $resolver = new \Illuminate\Database\ConnectionResolver(); $resolver->addConnection('default', $conn); $resolver->setDefaultConnection('default'); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); }
/** * Sets up the Eloquent Connection Resolver with the given PDO connection. * * @param PDO $pdo * @param string $driverName * @param string $tablePrefix * @return void */ public static function setupDatabaseResolver(PDO $pdo, $driverName = null, $tablePrefix = '') { // If Eloquent doesn't exist, then we must assume they are using their own providers. if (class_exists('Illuminate\\Database\\Eloquent\\Model')) { if (is_null($driverName)) { $driverName = $pdo->getAttribute(PDO::ATTR_DRIVER_NAME); } Eloquent::setConnectionResolver(new ConnectionResolver($pdo, $driverName, $tablePrefix)); } }
private function setConnectionResolver() { if ($this->checkTablesExists() && is_null(Model::getConnectionResolver())) { $res = new ConnectionResolver(); DB::pretend(function ($db) use($res) { $res->addConnection(config('database.default'), $db); $res->setDefaultConnection(config('database.default')); }); Model::setConnectionResolver($res); } }
public function call() { $container = new Illuminate\Container\Container(); $connFactory = new \Illuminate\Database\Connectors\ConnectionFactory($container); $conn = $connFactory->make(array('driver' => 'mysql', 'host' => '127.0.0.1', 'database' => 'flysmuthe', 'username' => \config\SecureConfig::$dbUsername, 'password' => \config\SecureConfig::$dbPassword, 'charset' => 'utf8', 'collation' => 'utf8_general_ci', 'prefix' => '')); $resolver = new \Illuminate\Database\ConnectionResolver(); $resolver->addConnection('default', $conn); $resolver->setDefaultConnection('default'); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); //Call next middleware $this->next->call(); }
public function __construct() { $this->ci =& get_instance(); $config = $this->ci->db; // Get the DB object $pdo = new PDO('mysql:host=' . $config->hostname . ';dbname=' . $config->database, $config->username, $config->password); $drivers = array('mysql' => '\\Illuminate\\Database\\MySqlConnection', 'pgsql' => '\\Illuminate\\Database\\PostgresConnection', 'sqlite' => '\\Illuminate\\Database\\SQLiteConnection'); $conn = new $drivers['mysql']($pdo, $config->database, $config->dbprefix); $resolver = new Illuminate\Database\ConnectionResolver(); $resolver->addConnection('default', $conn); $resolver->setDefaultConnection('default'); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); }
public function load() { // Database information : should be inject with DI $settings = array('driver' => 'sqlite', 'database' => 'vdm_posts_db.sqlite', 'prefix' => ''); // Bootstrap Eloquent ORM $container = new Container(); $connFactory = new \Illuminate\Database\Connectors\ConnectionFactory($container); $conn = $connFactory->make($settings); $resolver = new \Illuminate\Database\ConnectionResolver(); $resolver->addConnection('default', $conn); $resolver->setDefaultConnection('default'); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); }
/** * Creates a new Connection via the Factory then adds it to the resolver. If * this is the first time it is ran, it will also initialize the Eloquent * Model with the ConnectionResolver object so your models work. * * @param string Name of the connection * @param array The config array for the connection * @param bool Whether to make this the default connection * @return Illuminate\Database\Connectors\Connection */ public static function make($name, array $config, $default = false) { self::setupResolverAndFactory(); $conn = self::$factory->make($config); self::$resolver->addConnection($name, $conn); if ($default) { self::$resolver->setDefaultConnection($name); } if (!self::$modelInitialized) { Model::setConnectionResolver(self::$resolver); self::$modelInitialized = true; } return $conn; }
static function startUp(KernelInterface $kernel, ModuleInfo $moduleInfo) { $kernel->onRegisterServices(function (InjectorInterface $injector) { $injector->share(DatabaseAPI::class)->prepare(DatabaseAPI::class, function (DatabaseAPI $db) { $db->manager->setAsGlobal(); $db->manager->setEventDispatcher(new Dispatcher($db->manager->getContainer())); $db->manager->bootEloquent(); Model::setConnectionResolver($db); })->alias(ModelControllerInterface::class, ModelController::class)->share(ModelController::class)->share(MigrationsSettings::class)->alias(MigrationsInterface::class, Migrations::class); }); if ($kernel->getProfile() instanceof ConsoleProfile) { $kernel->onConfigure(function (ConsoleSettings $consoleSettings) { $consoleSettings->registerTasksFromClass(MigrationCommands::class); }); } }
/** * Creates a new instance of Sentry. * * @return Cartalyst\Sentry\Sentry */ public static function createSentry() { // If Eloquent doesn't exist, then we must assume they are using their own providers. if (class_exists('Illuminate\\Database\\Eloquent\\Model')) { // Retrieve what we need for our resolver $database = Database_Connection::instance(); $pdo = $database->connection(); $driverName = $database->driver_name(); $tablePrefix = $database->table_prefix(); // Make sure we're getting a PDO connection if (!$pdo instanceof PDO) { throw new \RuntimeException("Sentry will only work with PDO database connections."); } Eloquent::setConnectionResolver(new ConnectionResolver($pdo, $driverName, $tablePrefix)); } return new BaseSentry($userProvider = new UserProvider(new NativeHasher()), new GroupProvider(), new ThrottleProvider($userProvider), new FuelPHPSession(Session::instance()), new FuelPHPCookie(), Input::real_ip()); }
/** * Bootstrap the application events. * * @return void */ public function boot() { Model::setConnectionResolver($this->app['db']); Model::setEventDispatcher($this->app['events']); }
// To help the built-in PHP dev server, check if the request was actually for // something which should probably be served as a static file $file = __DIR__ . $_SERVER['REQUEST_URI']; if (is_file($file)) { return false; } } date_default_timezone_set('Europe/Istanbul'); require __DIR__ . '/../vendor/autoload.php'; // Database information $settings = array('driver' => 'mysql', 'host' => 'localhost', 'port' => 3306, 'database' => 'wtf_db', 'username' => 'root', 'password' => '', 'collation' => 'utf8_turkish_ci', 'charset' => 'utf8', 'prefix' => ''); // Bootstrap Eloquent ORM $container = new Illuminate\Container\Container(); $connFactory = new \Illuminate\Database\Connectors\ConnectionFactory($container); $conn = $connFactory->make($settings); $resolver = new \Illuminate\Database\ConnectionResolver(); $resolver->addConnection('default', $conn); $resolver->setDefaultConnection('default'); \Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver); session_start(); // Instantiate the app $settings = (require __DIR__ . '/../src/settings.php'); $app = new \Slim\App($settings); // Set up dependencies require __DIR__ . '/../src/dependencies.php'; // Register middleware require __DIR__ . '/../src/middleware.php'; // Register routes require __DIR__ . '/../src/routes.php'; // Run app $app->run();
public function testDateTimeAttributesReturnNullIfSetToNull() { $timestamps = ['created_at' => Carbon\Carbon::now(), 'updated_at' => Carbon\Carbon::now()]; $model = new EloquentDateModelStub(); Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver = m::mock('Illuminate\\Database\\ConnectionResolverInterface')); $resolver->shouldReceive('connection')->andReturn($mockConnection = m::mock('StdClass')); $mockConnection->shouldReceive('getQueryGrammar')->andReturn($mockConnection); $mockConnection->shouldReceive('getDateFormat')->andReturn('Y-m-d H:i:s'); $instance = $model->newInstance($timestamps); $instance->created_at = null; $this->assertNull($instance->created_at); }
/** * Bootstrap Eloquent so it is ready for usage. * * @return void */ public function bootEloquent() { Eloquent::setConnectionResolver($this->manager); // If we have an event dispatcher instance, we will go ahead and register it // with the Eloquent ORM, allowing for model callbacks while creating and // updating "model" instances; however, if it not necessary to operate. if ($dispatcher = $this->getEventDispatcher()) { Eloquent::setEventDispatcher($dispatcher); } }
/** * Bootstrap Eloquent. * * @return void */ public static function setUpBeforeClass() { Eloquent::setConnectionResolver(new DatabaseIntegrationTestConnectionResolver()); Eloquent::setEventDispatcher(new Illuminate\Events\Dispatcher()); }
/** * Bootstrap Eloquent. * * @return void */ public static function setUpBeforeClass() { Eloquent::setConnectionResolver(new ConnectionResolver()); }
/** * Register the database connections with the Eloquent ORM. * * @return void */ protected function registerEloquent() { Model::setConnectionResolver($this->app['db']); }
public function boot(Application $app) { \Illuminate\Database\Eloquent\Model::setConnectionResolver($app['db.resolver']); }
/** * Prepare the Eloquent ORM for use. * * @return void */ public function bootEloquent() { Eloquent\Model::setConnectionResolver($this->manager); Eloquent\Model::setEventDispatcher($this->config['events']); }
/** * Build a fixture instance. * * @return void */ protected function buildFixture() { if ($this->fixture) { return; } $this->db = $this->buildDB(); $str = new Str(); $this->fixture = Fixture::getInstance(); $repository = new Eloquent($this->db, $str); $this->fixture->setDriver($repository); // Bootstrap Eloquent $sqliteConnection = new SQLiteConnection($this->db); $resolver = new ConnectionResolver(array('sqlite' => $sqliteConnection)); $resolver->setDefaultConnection('sqlite'); Model::setConnectionResolver($resolver); }
/** * Register the service provider. * * @return void */ public function register() { $this->app->singleton('Illuminate\\Database\\ConnectionInterface', function () { $factory = new ConnectionFactory($this->app); $connection = $factory->make($this->app['config']->get('fluxbb.database')); $connection->setEventDispatcher($this->app->make('Illuminate\\Contracts\\Events\\Dispatcher')); $connection->setFetchMode(PDO::FETCH_CLASS); return $connection; }); $this->app->singleton('Illuminate\\Database\\ConnectionResolverInterface', function () { $resolver = new ConnectionResolver(['fluxbb' => $this->app->make('Illuminate\\Database\\ConnectionInterface')]); $resolver->setDefaultConnection('fluxbb'); return $resolver; }); if (Core::isInstalled()) { $this->app->booting(function () { $resolver = $this->app->make('Illuminate\\Database\\ConnectionResolverInterface'); Model::setConnectionResolver($resolver); }); } }