/**
  * This is called after initializing the model.
  *
  * @param Phalcon\Events\Event $event
  * @param Phalcon\Mvc\Model\Manager $manager
  * @param mixed $model
  */
 public function afterInitialize(Event $event, ModelsManager $manager, $model)
 {
     $reflector = $this->annotations->get($model);
     $annotations = $reflector->getClassAnnotations();
     if ($annotations) {
         foreach ($annotations as $annotation) {
             switch ($annotation->getName()) {
                 case 'ORM\\Source':
                     $arguments = $annotation->getArguments();
                     $manager->setModelSource($model, $arguments[0]);
                     break;
                 case 'ORM\\HasMany':
                     $arguments = $annotation->getArguments();
                     $manager->addHasMany($model, $arguments[0], $arguments[1], $arguments[2]);
                     break;
                 case 'ORM\\BelongsTo':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[3])) {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3]);
                     } else {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2]);
                     }
                     break;
             }
         }
     }
 }
Example #2
0
 public function testCamelCaseRelation()
 {
     $this->specify("CamelCase relation calls should be the same cache", function () {
         $this->modelsManager->registerNamespaceAlias('AlbumORama', 'Phalcon\\Test\\Models\\AlbumORama');
         $album = Albums::findFirst();
         $album->artist->name = 'NotArtist';
         expect($album->artist->name)->equals($album->Artist->name);
     });
 }
Example #3
0
 /**
  * @param $sType
  * @return array
  */
 public function getTagBindsByType($sType)
 {
     $this->check();
     $m = new Manager();
     $m->setDI($this->getDI());
     $b = $m->createBuilder();
     $aResult = $b->from('TagBind')->join('Tags', 'Tags.id = TagBind.tag')->join('TagTypes', 'TagTypes.id = Tags.tag_type')->where('TagTypes.type = :t: AND TagBind.entity_type = :et: AND TagBind.entity_id = :ei:')->getQuery()->execute(array('t' => $sType, 'et' => $this->entity_type, 'ei' => $this->getId()));
     return $aResult;
 }
Example #4
0
 /**
  * This is called after initialize the model.
  *
  * @param Event         $event   Event object.
  * @param ModelsManager $manager Model manager
  * @param AbstractModel $model   Model object.
  *
  * @return string
  */
 public function afterInitialize(Event $event, ModelsManager $manager, $model)
 {
     //Reflector
     $reflector = $this->annotations->get($model);
     /**
      * Read the annotations in the class' docblock
      */
     $annotations = $reflector->getClassAnnotations();
     if ($annotations) {
         /**
          * Traverse the annotations
          */
         foreach ($annotations as $annotation) {
             switch ($annotation->getName()) {
                 /**
                  * Initializes the model's source
                  */
                 case 'Source':
                     $arguments = $annotation->getArguments();
                     $manager->setModelSource($model, $arguments[0]);
                     break;
                     /**
                      * Initializes Has-Many relations
                      */
                 /**
                  * Initializes Has-Many relations
                  */
                 case 'HasMany':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[3])) {
                         $manager->addHasMany($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3]);
                     } else {
                         $manager->addHasMany($model, $arguments[0], $arguments[1], $arguments[2]);
                     }
                     break;
                     /**
                      * Initializes BelongsTo relations
                      */
                 /**
                  * Initializes BelongsTo relations
                  */
                 case 'BelongsTo':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[3])) {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3]);
                     } else {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2]);
                     }
                     break;
             }
         }
     }
     return $event->getType();
 }
Example #5
0
 public function testSnapshotNormalComplex()
 {
     $this->specify("Normal complex snapshots don't work", function () {
         $robots = $this->modelsManager->executeQuery('SELECT * FROM ' . SnapshotRobots::class);
         foreach ($robots as $robot) {
             $robot->name = 'Some';
             $robot->year = 1999;
             expect($robot->hasChanged('name'))->true();
             expect($robot->hasChanged('year'))->true();
             expect($robot->hasChanged('type'))->false();
             expect($robot->hasChanged())->true();
             expect($robot->getChangedFields())->equals(array('name', 'year'));
         }
         $robots = $this->modelsManager->executeQuery('SELECT robot.*, parts.* FROM ' . SnapshotRobots::class . ' robot JOIN ' . SnapshotRobotsParts::class . ' parts');
         foreach ($robots as $row) {
             $row->robot->name = 'Some';
             $row->robot->year = 1999;
             expect($row->robot->hasChanged('name'))->true();
             expect($row->robot->hasChanged('year'))->true();
             expect($row->robot->hasChanged('type'))->false();
             expect($row->robot->hasChanged())->true();
             expect($row->robot->getChangedFields())->equals(array('name', 'year'));
             $this->assertFalse($row->parts->hasSnapshotData());
         }
     });
 }
Example #6
0
 public function getWriteConnection($model)
 {
     if ($this->getDI()->getDbMaster()) {
         $this->setWriteConnectionService($model, 'dbMaster');
     }
     return parent::getWriteConnection($model);
 }
Example #7
0
 /**
  * @return self
  * @throws Phalcon\Exception
  */
 public function init()
 {
     /** @var Phalcon\DI $di */
     $di = $this->getDI();
     $di->setShared('db', (new Orm\Database\Adapter($di))->resolve());
     $di->setShared('modelsManager', function () use($di) {
         $eventManager = $di->get('eventsManager');
         $modelsManager = new ModelsManager();
         $modelsManager->setEventsManager($eventManager);
         $eventManager->attach('modelsManager', new Orm\Annotation\Initializer());
         return $modelsManager;
     });
     $di->setShared('modelsMetadata', function () use($di) {
         $metadataAdapter = (new Orm\Metadata\Adapter($di))->resolve();
         $metadataAdapter->setStrategy(new Orm\Annotation\MetaDataInitializer());
         return $metadataAdapter;
     });
     return $this;
 }
 /**
  * Stores a reusable record in the cache
  *
  * @param string $modelName
  * @param string $key
  * @param mixed  $records
  */
 public function setReusableRecords($modelName, $key, $records)
 {
     //If the model is Products use the APC cache
     if ($modelName == 'Products') {
         apc_store($key, $records);
         return;
     }
     //For the rest, use the memory cache
     parent::setReusableRecords($modelName, $key, $records);
 }
 /**
  * get a list of hasOne tables, simlar to getParent but more inclusive
  *
  * @return string or false
  */
 public function getHasOnes()
 {
     $modelNameSpace = $this->relation->getReferencedModel();
     $list = [];
     $relationships = $this->modelManager->getRelations($modelNameSpace);
     foreach ($relationships as $relation) {
         $refType = $relation->getType();
         if ($refType == 1) {
             $list[] = $relation->getReferencedModel();
         }
     }
     return $list;
 }
 /**
  * This is called after initialize the model
  *
  * @param Phalcon\Events\Event $event
  */
 public function afterInitialize(Event $event, ModelsManager $manager, ModelInterface $model)
 {
     //Reflector
     $reflector = $this->annotations->get($model);
     /**
      * Read the annotations in the class' docblock
      */
     $annotations = $reflector->getClassAnnotations();
     if ($annotations) {
         /**
          * Traverse the annotations
          */
         foreach ($annotations as $annotation) {
             switch ($annotation->getName()) {
                 /**
                  * Initializes the model's source
                  */
                 case 'Source':
                     $arguments = $annotation->getArguments();
                     $manager->setModelSource($model, $arguments[0]);
                     break;
                     /**
                      * Initializes Has-Many relations
                      */
                 /**
                  * Initializes Has-Many relations
                  */
                 case 'HasMany':
                     $arguments = $annotation->getArguments();
                     $manager->addHasMany($model, $arguments[0], $arguments[1], $arguments[2]);
                     break;
                     /**
                      * Initializes Has-Many relations
                      */
                 /**
                  * Initializes Has-Many relations
                  */
                 case 'BelongsTo':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[3])) {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3]);
                     } else {
                         $manager->addBelongsTo($model, $arguments[0], $arguments[1], $arguments[2]);
                     }
                     break;
                     /**
                      * Initializes has-One relations
                      */
                 /**
                  * Initializes has-One relations
                  */
                 case 'hasOne':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[3])) {
                         $manager->addHasOne($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3]);
                     } else {
                         $manager->addHasOne($model, $arguments[0], $arguments[1], $arguments[2]);
                     }
                     break;
                     /**
                      * Initializes hasManyToMany relations
                      */
                 /**
                  * Initializes hasManyToMany relations
                  */
                 case 'hasManyToMany':
                     $arguments = $annotation->getArguments();
                     if (isset($arguments[6])) {
                         $manager->addHasManyToMany($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6]);
                     } else {
                         $manager->addHasManyToMany($model, $arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5]);
                     }
                     break;
                     /**
                      * Initializes the model's Behavior
                      */
                 /**
                  * Initializes the model's Behavior
                  */
                 case 'Behavior':
                     $arguments = $annotation->getArguments();
                     $behaviorName = $arguments[0];
                     if (isset($arguments[1])) {
                         $manager->addBehavior($model, new $behaviorName($arguments[1]));
                     } else {
                         $manager->addBehavior($model, new $behaviorName());
                     }
                     break;
                     /**
                      * Initializes the model's source connection
                      */
                 /**
                  * Initializes the model's source connection
                  */
                 case 'setConnectionService':
                     $arguments = $annotation->getArguments();
                     $manager->setConnectionService($model, $arguments[0]);
                     break;
             }
         }
     }
 }
Example #11
0
 /**
  * Initialize the Database connection.
  *
  * Database connection is created based in the parameters defined in the configuration file.
  *
  * @param DiInterface   $di     Dependency Injector
  * @param Config        $config App config
  * @param EventsManager $em     Events Manager
  *
  * @return void
  */
 protected function initDatabase(DiInterface $di, Config $config, EventsManager $em)
 {
     $di->setShared('db', function () use($config, $em, $di) {
         $config = $config->get('database')->toArray();
         $adapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . $config['adapter'];
         unset($config['adapter']);
         /** @var \Phalcon\Db\Adapter\Pdo $connection */
         $connection = new $adapter($config);
         // Listen all the database events
         $em->attach('db', function ($event, $connection) use($di) {
             /**
              * @var \Phalcon\Events\Event $event
              * @var \Phalcon\Db\AdapterInterface $connection
              * @var \Phalcon\DiInterface $di
              */
             if ($event->getType() == 'beforeQuery') {
                 $variables = $connection->getSQLVariables();
                 $string = $connection->getSQLStatement();
                 if ($variables) {
                     $string .= ' [' . join(',', $variables) . ']';
                 }
                 // To disable logging change logLevel in config
                 $di->get('logger', ['db.log'])->debug($string);
             }
         });
         // Assign the eventsManager to the db adapter instance
         $connection->setEventsManager($em);
         return $connection;
     });
     $di->setShared('modelsManager', function () use($em) {
         $modelsManager = new ModelsManager();
         $modelsManager->setEventsManager($em);
         return $modelsManager;
     });
     $di->setShared('modelsMetadata', function () use($config, $em) {
         $config = $config->get('metadata')->toArray();
         $adapter = '\\Phalcon\\Mvc\\Model\\Metadata\\' . $config['adapter'];
         unset($config['adapter']);
         $metaData = new $adapter($config);
         return $metaData;
     });
 }
Example #12
0
 /**
  * Setup database connection.
  *
  * @param array|null $connectionSettings Connection data.
  *
  * @return void
  */
 protected function _setupDatabase($connectionSettings = null)
 {
     if ($connectionSettings != null) {
         $this->config->database = new Config($connectionSettings);
     }
     $config = $this->config;
     $eventsManager = new EventsManager();
     $adapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . $config->database->adapter;
     $connection = new $adapter(["host" => $config->database->host, "port" => $config->database->port, "username" => $config->database->username, "password" => $config->database->password, "dbname" => $config->database->dbname]);
     $this->di->set('db', $connection);
     $this->di->set('modelsManager', function () use($config, $eventsManager) {
         $modelsManager = new ModelManager();
         $modelsManager->setEventsManager($eventsManager);
         //Attach a listener to models-manager
         $eventsManager->attach('modelsManager', new ModelAnnotationsInitializer());
         return $modelsManager;
     }, true);
 }
Example #13
0
 /**
  * Tests Manager::isVisibleModelProperty
  *
  * @author Serghei Iakovlev <*****@*****.**>
  * @since  2016-08-12
  */
 public function testModelPublicProperties()
 {
     $this->specify('The Manager::isVisibleModelProperty does not check public property correctly', function ($property, $expected) {
         expect($this->modelsManager->isVisibleModelProperty(new Customers(), $property))->equals($expected);
     }, ['examples' => [['id', true], ['document_id', true], ['customer_id', true], ['first_name', true], ['some_field', false], ['', false], ['protected_field', false], ['private_field', false]]]);
 }
 /**
  * Init database.
  *
  * @param DI $di Dependency Injection.
  * @param Config $config Config object.
  * @param EventsManager $eventsManager Event manager.
  *
  * @return Pdo
  */
 protected function _initDatabase($di, $config, $eventsManager)
 {
     $adapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . ucfirst($config->dbMaster->adapter);
     /** @var Pdo $connMaster */
     $connMaster = new $adapter(["host" => $config->dbMaster->host, "port" => $config->dbMaster->port, "username" => $config->dbMaster->username, "password" => $config->dbMaster->password, "dbname" => $config->dbMaster->dbname, "prefix" => $config->dbMaster->prefix, 'options' => [\PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES '" . $config->dbMaster->charset . "'", \PDO::ATTR_CASE => \PDO::CASE_LOWER, \PDO::ATTR_PERSISTENT => true]]);
     $connSlave = new $adapter(["host" => $config->dbSlave->host, "port" => $config->dbSlave->port, "username" => $config->dbSlave->username, "password" => $config->dbSlave->password, "dbname" => $config->dbSlave->dbname, "prefix" => $config->dbSlave->prefix, 'options' => [\PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES '" . $config->dbSlave->charset . "'", \PDO::ATTR_CASE => \PDO::CASE_LOWER, \PDO::ATTR_PERSISTENT => true]]);
     $isDebug = $config->debug;
     $isProfiler = $config->profiler;
     if ($isDebug || $isProfiler) {
         // Attach logger & profiler.
         $logger = null;
         $profiler = null;
         if ($isDebug) {
             $logger = write_log("database", "");
         }
         if ($isProfiler) {
             $profiler = new DatabaseProfiler();
             $di->set('profiler', $profiler);
         }
         $eventsManager->attach('db', function ($event, $connection) use($logger, $profiler) {
             if ($event->getType() == 'beforeQuery') {
                 $statement = $connection->getSQLStatement();
                 if ($logger) {
                     $logger->log($statement, Logger::INFO);
                 }
                 if ($profiler) {
                     $profiler->startProfile($statement);
                 }
             }
             if ($event->getType() == 'afterQuery') {
                 // Stop the active profile.
                 if ($profiler) {
                     $profiler->stopProfile();
                 }
             }
         });
         $connMaster->setEventsManager($eventsManager);
         $connSlave->setEventsManager($eventsManager);
     }
     $di->set('dbMaster', $connMaster);
     $di->set('db', $connSlave);
     $di->set('modelsManager', function () use($config, $eventsManager) {
         $modelsManager = new ModelsManager();
         $modelsManager->setEventsManager($eventsManager);
         return $modelsManager;
     }, true);
     return $connMaster;
 }
Example #15
0
 /**
  * Initializes the models manager
  */
 public function initModelsmanager($options = [])
 {
     $this->di->set('modelsManager', function () {
         $eventsManager = new PhEventsManager();
         $modelsManager = new PhModelsManager();
         $modelsManager->setEventsManager($eventsManager);
         //Attach a listener to models-manager
         $eventsManager->attach('modelsManager', new FlyAnnotationsInitializer());
         return $modelsManager;
     });
 }
 /**
  * Init database.
  *
  * @param DI            $di            Dependency Injection.
  * @param Config        $config        Config object.
  * @param EventsManager $eventsManager Event manager.
  *
  * @return Pdo
  */
 protected function _initDatabase($di, $config, $eventsManager)
 {
     if (!$config->installed) {
         return;
     }
     $adapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . $config->database->adapter;
     /** @var Pdo $connection */
     $connection = new $adapter(["host" => $config->database->host, "port" => $config->database->port, "username" => $config->database->username, "password" => $config->database->password, "dbname" => $config->database->dbname]);
     $isDebug = $config->application->debug;
     $isProfiler = $config->application->profiler;
     if ($isDebug || $isProfiler) {
         // Attach logger & profiler.
         $logger = null;
         $profiler = null;
         if ($isDebug) {
             $logger = new File($config->application->logger->path . "db.log");
         }
         if ($isProfiler) {
             $profiler = new DatabaseProfiler();
         }
         $eventsManager->attach('db', function ($event, $connection) use($logger, $profiler) {
             if ($event->getType() == 'beforeQuery') {
                 $statement = $connection->getSQLStatement();
                 if ($logger) {
                     $logger->log($statement, Logger::INFO);
                 }
                 if ($profiler) {
                     $profiler->startProfile($statement);
                 }
             }
             if ($event->getType() == 'afterQuery') {
                 // Stop the active profile.
                 if ($profiler) {
                     $profiler->stopProfile();
                 }
             }
         });
         if ($profiler && $di->has('profiler')) {
             $di->get('profiler')->setDbProfiler($profiler);
         }
         $connection->setEventsManager($eventsManager);
     }
     $di->set('db', $connection);
     $di->set('modelsManager', function () use($config, $eventsManager) {
         $modelsManager = new ModelsManager();
         $modelsManager->setEventsManager($eventsManager);
         // Attach a listener to models-manager
         $eventsManager->attach('modelsManager', new ModelAnnotationsInitializer());
         return $modelsManager;
     }, true);
     /**
      * If the configuration specify the use of metadata adapter use it or use memory otherwise.
      */
     $di->set('modelsMetadata', function () use($config) {
         if (!$config->application->debug && isset($config->application->metadata)) {
             $metaDataConfig = $config->application->metadata;
             $metadataAdapter = '\\Phalcon\\Mvc\\Model\\Metadata\\' . $metaDataConfig->adapter;
             $metaData = new $metadataAdapter($config->application->metadata->toArray());
         } else {
             $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
         }
         $metaData->setStrategy(new StrategyAnnotations());
         return $metaData;
     }, true);
     return $connection;
 }
 public function run(Api $api, DiInterface $di, Config $config)
 {
     /**
      * @description Config - \Phalcon\Config
      */
     $di->setShared(Services::CONFIG, $config);
     /**
      * @description Phalcon - \Phalcon\Db\Adapter\Pdo\Mysql
      */
     $di->set(Services::DB, function () use($config, $di) {
         $config = $config->get('database')->toArray();
         $adapter = $config['adapter'];
         unset($config['adapter']);
         $class = 'Phalcon\\Db\\Adapter\\Pdo\\' . $adapter;
         $connection = new $class($config);
         // Assign the eventsManager to the db adapter instance
         $connection->setEventsManager($di->get(Services::EVENTS_MANAGER));
         return $connection;
     });
     /**
      * @description Phalcon - \Phalcon\Mvc\Url
      */
     $di->set(Services::URL, function () use($config) {
         $url = new UrlResolver();
         $url->setBaseUri($config->get('application')->baseUri);
         return $url;
     });
     /**
      * @description Phalcon - \Phalcon\Mvc\View\Simple
      */
     $di->set(Services::VIEW, function () use($config) {
         $view = new View();
         $view->setViewsDir($config->get('application')->viewsDir);
         return $view;
     });
     /**
      * @description Phalcon - EventsManager
      */
     $di->setShared(Services::EVENTS_MANAGER, function () use($di, $config) {
         return new EventsManager();
     });
     /**
      * @description Phalcon - TokenParsers
      */
     $di->setShared(Services::TOKEN_PARSER, function () use($di, $config) {
         return new JWTTokenParser($config->get('authentication')->secret, JWTTokenParser::ALGORITHM_HS256);
     });
     /**
      * @description Phalcon - AuthManager
      */
     $di->setShared(Services::AUTH_MANAGER, function () use($di, $config) {
         $authManager = new AuthManager($config->get('authentication')->expirationTime);
         $authManager->registerAccountType(UsernameAccountType::NAME, new UsernameAccountType());
         return $authManager;
     });
     /**
      * @description Phalcon - \Phalcon\Mvc\Model\Manager
      */
     $di->setShared(Services::MODELS_MANAGER, function () use($di) {
         $modelsManager = new ModelsManager();
         return $modelsManager->setEventsManager($di->get(Services::EVENTS_MANAGER));
     });
     /**
      * @description PhalconRest - \League\Fractal\Manager
      */
     $di->setShared(Services::FRACTAL_MANAGER, function () {
         $fractal = new FractalManager();
         $fractal->setSerializer(new CustomSerializer());
         return $fractal;
     });
     /**
      * @description PhalconRest - \PhalconRest\User\Service
      */
     $di->setShared(Services::USER_SERVICE, new UserService());
 }
Example #18
0
    $sessionAdapter = $di->get('config')->application->session->adapter;
    $session = new $sessionAdapter($di->get('config')->application->session->options->toArray());
    $session->start();
    return $session;
}, true);
/**
 * This service controls the initialization of models, keeping record of relations
 * between the different models of the application.
 */
$di->setShared('collectionManager', function () use($eventsManager) {
    $collectionManager = new CollectionManager();
    $collectionManager->setEventsManager($eventsManager);
    return $collectionManager;
});
$di->setShared('modelsManager', function () use($eventsManager) {
    $modelsManager = new ModelsManager();
    $modelsManager->setEventsManager($eventsManager);
    return $modelsManager;
});
// Set the views cache service
$di->set('viewCache', function () use($di) {
    $config = $di->get('config');
    if ($config->application->debug) {
        return new MemoryBackend(new FrontendNone());
    } else {
        // Cache data for one day by default
        $frontCache = new FrontendOutput(['lifetime' => $config->cache->lifetime]);
        return new FileCache($frontCache, ['cacheDir' => $config->cache->cacheDir, 'prefix' => $config->cache->prefix]);
    }
});
//  Setting up the view component
Example #19
0
 /**
  * Init database.
  *
  * @param DI            $di            Dependency Injection.
  * @param Config        $config        Config object.
  * @param EventsManager $eventsManager Event manager.
  *
  * @return Pdo
  */
 protected function _initDb($di, $config, $eventsManager)
 {
     $adapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . $config->db->mysql->adapter;
     /** @var Pdo $connection */
     $connection = new $adapter(['host' => $config->db->mysql->host, 'port' => $config->db->mysql->port, 'username' => $config->db->mysql->username, 'password' => $config->db->mysql->password, 'dbname' => $config->db->mysql->dbname]);
     $isProfiler = $config->global->profiler;
     if ($isProfiler) {
         // Attach logger & profiler.
         $profiler = null;
         if ($isProfiler) {
             $profiler = new PhDbProfiler();
         }
         $eventsManager->attach('db', function ($event, $connection) use($profiler) {
             if ($event->getType() == 'beforeQuery') {
                 $statement = $connection->getSQLStatement();
                 if ($profiler) {
                     $profiler->startProfile($statement);
                 }
             }
             if ($event->getType() == 'afterQuery') {
                 // Stop the active profile.
                 if ($profiler) {
                     $profiler->stopProfile();
                 }
             }
         });
         if ($profiler && $di->has('profiler')) {
             $di->get('profiler')->setDbProfiler($profiler);
         }
         $connection->setEventsManager($eventsManager);
     }
     $di->set('db', $connection);
     /**
      * Add db service connect to five.vn database
      */
     $di->set('dbfive', function () use($config) {
         $fiveAdapter = '\\Phalcon\\Db\\Adapter\\Pdo\\' . $config->db->dbfive->adapter;
         return new $fiveAdapter(['host' => $config->db->dbfive->host, 'port' => $config->db->dbfive->port, 'username' => $config->db->dbfive->username, 'password' => $config->db->dbfive->password, 'dbname' => $config->db->dbfive->dbname]);
     });
     $di->set('modelsManager', function () use($config, $eventsManager) {
         $modelsManager = new PhModelsManager();
         $modelsManager->setEventsManager($eventsManager);
         // Attach a listener to models-manager
         $eventsManager->attach('modelsManager', new ModelAnnotationsInitializer());
         return $modelsManager;
     }, true);
     /**
      * If the configuration specify the use of metadata adapter use it or use memory otherwise.
      */
     $di->set('modelsMetadata', function () use($config) {
         if (ENV == ENV_PRODUCTION && isset($config->global->metadata)) {
             $metaDataConfig = $config->global->metadata;
             $metadataAdapter = '\\Phalcon\\Mvc\\Model\\Metadata\\' . $metaDataConfig->adapter;
             $metaData = new $metadataAdapter($config->global->metadata->toArray());
         } else {
             $metaData = new \Phalcon\Mvc\Model\MetaData\Memory();
         }
         $metaData->setStrategy(new PhStrategyAnnotations());
         return $metaData;
     }, true);
     return $connection;
 }