/** * 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; } } } }
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); }); }
/** * @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; }
/** * 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(); }
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()); } }); }
public function getWriteConnection($model) { if ($this->getDI()->getDbMaster()) { $this->setWriteConnectionService($model, 'dbMaster'); } return parent::getWriteConnection($model); }
/** * @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; } } } }
/** * 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; }); }
/** * 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); }
/** * 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; }
/** * 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()); }
$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
/** * 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; }