protected function setUp() { $pathToEntities = [__DIR__ . '/Entity']; $isDevMode = true; $connectionParams = array('user' => 'user', 'password' => 'password', 'driver' => 'pdo_sqlite', 'memory' => true); $config = Setup::createConfiguration($isDevMode); $driver = new AnnotationDriver(new AnnotationReader(), $pathToEntities); AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); $this->em = EntityManager::create($connectionParams, $config); /* * Устанавливаем фикстуры, знаю что можно это сделать более универсально, но ... в данном контексте мне больше и не надо */ $conn = $this->em->getConnection(); $conn->exec("CREATE TABLE clients (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);"); $conn->exec("CREATE TABLE authors (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);"); $conn->exec("CREATE TABLE books (id INTEGER, owner_id INTEGER, name TEXT, surname TEXT, CONSTRAINT 'pk' PRIMARY KEY (id, owner_id));"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Nikita','Sapogov')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Alex','Ivanov')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Sura','Soir')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Vasya','Poliakocv')"); $conn->exec("INSERT INTO books (id, owner_id, name) VALUES (1,1,'SuperBookNAme')"); $conn->exec("INSERT INTO books (id, owner_id, name) VALUES (2,15,'SuperBookNAme2')"); $conn->exec("INSERT INTO books (id, owner_id, name) VALUES (3,3,'SuperBookNAme3')"); }
protected function setUp() { AnnotationRegistry::registerLoader('class_exists'); $this->reader = new SimpleAnnotationReader(); $this->reader->addNamespace('Bazinga\\Bundle\\GeocoderBundle\\Mapping\\Annotations'); $this->driver = new AnnotationDriver($this->reader); }
/** * Add annotations into Doctrine Annotation Registry. * It use <code>\class_exist</code> function with its autoload feature (that use registered autoloader). * Only class in the namespace "MacFJA\Validator\Annotation" are concerned by this loader */ public static function registerAnnotations() { if (!self::$annotationsRegistered) { AnnotationRegistry::registerLoader(array(get_called_class(), 'loadAnnotation')); self::$annotationsRegistered = true; } }
/** * */ public static function registerAutoloader() { if (!self::$registered) { $classLoader = self::getAutoloader(); AnnotationRegistry::registerLoader(array($classLoader, 'loadClass')); } }
protected function setUp() { $pathToEntities = [__DIR__ . '/Entity']; $isDevMode = true; $dbPath = __DIR__ . "/db.db"; $connectionParams = array('user' => 'user', 'password' => 'password', 'driver' => 'pdo_sqlite', 'path' => $dbPath); if (file_exists($dbPath)) { unlink($dbPath); } $config = Setup::createConfiguration($isDevMode); $driver = new AnnotationDriver(new AnnotationReader(), $pathToEntities); AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); $this->em = EntityManager::create($connectionParams, $config); /* * Устанавливаем фикстуры, знаю что можно это сделать более универсально, но ... в данном контексте мне больше и не надо */ $conn = $this->em->getConnection(); /* * ВНИМАНИЕ: Поля в таблице сделаны так, что сравниваются они не зависимо от регистра! */ $conn->exec("CREATE TABLE clients (id INTEGER PRIMARY KEY, name TEXT COLLATE NOCASE, surname TEXT COLLATE NOCASE);"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Никита','Сапогов')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Валерий','Иванов')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Сурий','Мазур')"); $conn->exec("INSERT INTO clients (name,surname) VALUES('Вася','Корибасов Иван')"); }
/** * Creates RAD app kernel, which you can use to manage your app. * * Loads intl, swift and then requires/initializes/returns custom * app kernel. * * @param ClassLoader $loader Composer class loader * @param string $environment Environment name * @param Boolean $debug Debug mode? * * @return RadAppKernel */ public static function createAppKernel(ClassLoader $loader, $environment, $debug) { require_once __DIR__ . '/RadAppKernel.php'; if (null === self::$projectRootDir) { self::$projectRootDir = realpath(__DIR__ . '/../../../../../../..'); } $autoloadAnnotations = function () use($loader) { AnnotationRegistry::registerLoader(array($loader, 'loadClass')); }; $autoloadIntl = function ($rootDir) use($loader) { if (!function_exists('intl_get_error_code')) { require_once $rootDir . '/vendor/symfony/symfony/src/' . 'Symfony/Component/Locale/Resources/stubs/functions.php'; $loader->add(null, $rootDir . '/vendor/symfony/symfony/src/Symfony/Component/Locale/Resources/stubs'); } }; $autoloadSwift = function ($rootDir) use($loader) { require_once $rootDir . '/vendor/swiftmailer/swiftmailer/lib/classes/Swift.php'; \Swift::registerAutoload($rootDir . '/vendor/swiftmailer/swiftmailer/lib/swift_init.php'); }; $loader->add(null, self::$projectRootDir . '/src'); if (file_exists($custom = self::$projectRootDir . '/app/autoload.php')) { require $custom; } else { $autoloadAnnotations(); $autoloadIntl(self::$projectRootDir); $autoloadSwift(self::$projectRootDir); } return new \RadAppKernel($environment, $debug); }
public function register() { \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists'); $this->app->singleton('serializer', function ($app) { return SerializerBuilder::create()->setObjectConstructor(new DoctrineObjectConstructor($app->make('registry'), new UnserializeObjectConstructor()))->build(); }); }
public function setUp() { AnnotationRegistry::registerLoader('class_exists'); $this->serializer = SerializerBuilder::create()->configureHandlers(function (HandlerRegistry $registry) { $registry->registerSubscribingHandler(new RamseyUuidHandler()); })->build(); }
/** * constructor */ public function __construct() { // load database configuration from CodeIgniter require APPPATH . 'config/database.php'; $doctrineClassLoader = new ClassLoader('Doctrine', FCPATH . 'vendors'); $doctrineClassLoader->register(); $symfonyClassLoader = new ClassLoader('Symfony', FCPATH . 'vendors/Doctrine'); $symfonyClassLoader->register(); $entityClassLoader = new ClassLoader('Entity', APPPATH . 'models'); $entityClassLoader->register(); $config = Doctrine\ORM\Tools\Setup::createConfiguration(ENVIRONMENT !== 'production'); $driverImpl = new AnnotationDriver(new AnnotationReader(), [APPPATH . 'models']); AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driverImpl); // Proxy configuration $config->setProxyDir(APPPATH . 'models/Proxies'); $config->setProxyNamespace('Proxies'); if (ENVIRONMENT === 'production') { // Set up caches $cache = new ArrayCache(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); } else { // Set up logger // $logger = new EchoSQLLogger; // $config->setSQLLogger($logger); $config->setAutoGenerateProxyClasses(TRUE); } // Database connection information $connectionOptions = array('driver' => $db[$active_group]['dbdriver'], 'user' => $db[$active_group]['username'], 'password' => $db[$active_group]['password'], 'host' => $db[$active_group]['hostname'], 'port' => $db[$active_group]['port'], 'dbname' => $db[$active_group]['database'], 'charset' => $db[$active_group]['char_set'], 'collation' => $db[$active_group]['dbcollat']); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
public static function bootstrap($dbConfig, $package, $applicationMode = 'development') { $packagePath = str_replace('\\', DIRECTORY_SEPARATOR, $package); $paths = array(__DIR__ . '/../../../../../../../application/packages/' . $packagePath . '/models/entities'); $isDevMode = $applicationMode == 'development' ? true : false; $dbParams = array('driver' => $dbConfig->driver, 'user' => $dbConfig->username, 'password' => $dbConfig->password, 'dbname' => $dbConfig->dbname); if ($applicationMode == "development") { $cache = new \Doctrine\Common\Cache\ArrayCache(); } else { $cache = new \Doctrine\Common\Cache\ApcCache(); } $config = Setup::createConfiguration($isDevMode); $driver = new AnnotationDriver(new AnnotationReader(), $paths); // registering noop annotation autoloader - allow all annotations by default AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); $proxyDir = __DIR__ . '/../../../../../../../application/packages/' . $packagePath . '/models/proxies'; $proxyNamespace = $package . '\\models\\proxies\\'; $config->setProxyDir($proxyDir); $config->setProxyNamespace($proxyNamespace); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); if ($applicationMode == "development") { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } return EntityManager::create($dbParams, $config); }
public function __construct() { // load database configuration from CodeIgniter require_once APPPATH . 'config/database.php'; $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries'); $doctrineClassLoader->register(); $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/")); $entitiesClassLoader->register(); $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies'); $proxiesClassLoader->register(); // Set up caches $config = new Configuration(); $cache = new ArrayCache(); $config->setMetadataCacheImpl($cache); $reader = new AnnotationReader(); $driverImpl = new AnnotationDriver($reader, array(APPPATH . "models/Entities")); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); // Proxy configuration $config->setProxyDir(APPPATH . '/models/proxies'); $config->setProxyNamespace('Proxies'); $config->setAutoGenerateProxyClasses(true); AnnotationRegistry::registerLoader('class_exists'); // Database connection information $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); }
/** * @param array $settings * @param bool $debug * @return EntityManager * @throws \Doctrine\ORM\ORMException */ public static function factory($settings, $debug = true) { if ($debug || !function_exists('apc_fetch')) { $cache = new ArrayCache(); } else { $cache = new ApcCache(); } $dbSettings = $settings['doctrine']; $config = new Configuration(); $config->setMetadataCacheImpl($cache); // Do not use default Annotation driver $driverImpl = new AnnotationDriver(new AnnotationReader(), $dbSettings['entities']); // Allow all annotations AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cache); $config->setProxyDir($dbSettings['proxy_path']); $config->setProxyNamespace('Zaralab\\Doctrine\\Proxies'); if ($debug) { $config->setAutoGenerateProxyClasses(true); } else { $config->setAutoGenerateProxyClasses(false); } $connectionOptions = $dbSettings['dbal']; return EntityManager::create($connectionOptions, $config); }
public function getFakedApiResponse($class) { AnnotationRegistry::registerLoader('class_exists'); $serializer = SerializerBuilder::create()->build(); $response = new $class(); return $serializer->serialize($response, 'json'); }
public function startTestSuite(\PHPUnit_Framework_TestSuite $suite) { $suiteName = $suite->getName(); if (-1 === $this->state) { echo "Testing {$suiteName}\n"; $this->state = 0; if (!class_exists('Doctrine\\Common\\Annotations\\AnnotationRegistry', false) && class_exists('Doctrine\\Common\\Annotations\\AnnotationRegistry')) { AnnotationRegistry::registerLoader('class_exists'); } if ($this->skippedFile = getenv('SYMFONY_PHPUNIT_SKIPPED_TESTS')) { $this->state = 1; if (file_exists($this->skippedFile)) { $this->state = 2; if (!($this->wasSkipped = (require $this->skippedFile))) { echo "All tests already ran successfully.\n"; $suite->setTests(array()); } } } } elseif (2 === $this->state) { $skipped = array(); foreach ($suite->tests() as $test) { if (!$test instanceof \PHPUnit_Framework_TestCase || isset($this->wasSkipped[$suiteName]['*']) || isset($this->wasSkipped[$suiteName][$test->getName()])) { $skipped[] = $test; } } $suite->setTests($skipped); } }
/** * * @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator * @return object */ public function createService(ServiceLocatorInterface $serviceLocator) { $manifest = $serviceLocator->get('manifest'); $extension = $serviceLocator->get('extension.odmcore'); $config = new Configuration(); $config->setProxyDir($extension->getProxyDir()); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($extension->getHydratorDir()); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB($extension->getDefaultDb()); $config->setClassMetadataFactoryName($extension->getClassMetadataFactory()); $config->setMetadataCacheImpl(new ArrayCache()); //create driver chain $chain = new MappingDriverChain(); foreach ($manifest->getModels() as $namespace => $path) { $driver = new AnnotationDriver(new AnnotationReader(), $path); $chain->addDriver($driver, $namespace); } $config->setMetadataDriverImpl($chain); //register filters foreach ($extension->getFilters() as $name => $class) { $config->addFilter($name, $class); } //create event manager $eventManager = new EventManager(); foreach ($manifest->getSubscribers() as $subscriber) { $eventManager->addEventSubscriber($serviceLocator->get($subscriber)); } //register annotations AnnotationRegistry::registerLoader(function ($className) { return class_exists($className); }); $conn = new Connection(null, array(), $config); return ModelManager::create($conn, $config, $eventManager); }
public function registerServices(\Phalcon\DiInterface $di) { //registrando annotations $this->registerAnnotationsFiles(['Column', 'Entity', 'GeneratedValue', 'HasLifecycleCallbacks', 'Id', 'PrePersist', 'PreUpdate', 'Table', 'ManyToOne', 'ManyToMany', 'JoinTable', 'JoinColumn']); //configurando entity manager $di->setShared('entityManager', function () use($di) { $infraConfig = $di->get('Infrastructure\\Config'); // $doctrine_config = Setup::createAnnotationMetadataConfiguration($infraConfig['ormMapper'], $di->get('App\Config')['devmode']); $config = Setup::createConfiguration($di->get('App\\Config')['devmode']); $driver = new AnnotationDriver(new AnnotationReader(), $infraConfig['ormMapper']); // registering noop annotation autoloader - allow all annotations by default AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); $entityManager = EntityManager::create($infraConfig['databases'][0], $config); $platform = $entityManager->getConnection()->getDatabasePlatform(); $platform->registerDoctrineTypeMapping('enum', 'string'); return $entityManager; }); $di->setShared('api', function () use($di) { $infraConfig = $di->get('Infrastructure\\Config'); return new Service\RESTClient($infraConfig['baseUrl']['api'], $infraConfig['credentials']); }); $di->setShared('geocodeApi', function () use($di) { return new Service\RESTClient('https://maps.googleapis.com/maps/api/geocode/json?&key=AIzaSyBwFWzpssaahZ7SfLZt6mv7PeZBFXImpmo&address='); }); }
public function __construct() { // Hack to ensure an attempt to autoload an annotation class is made AnnotationRegistry::registerLoader(function ($class) { return (bool) class_exists($class); }); }
/** * @param string $userId * @param string $userPassword * @param int $partnerId * @param string $partnerPassword * @param string $errorLanguage */ public function __construct($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage) { AnnotationRegistry::registerLoader('class_exists'); $this->afterbuyGlobal = new AfterbuyGlobal($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage); $this->client = new \GuzzleHttp\Client(array('base_uri' => $this->uri)); $this->serializer = SerializerBuilder::create()->configureHandlers(self::getHandlerConfiguration())->build(); }
protected static function registerValidatorAnnotations($force = false) { if (!$force && self::$registered) { return; } $refl = new \ReflectionClass(Validation::class); if ($refl->getFileName() === false) { // We can't setup the auto loading without knowing the path return; } $filePath = str_replace('\\', '/', $refl->getFileName()); // Detect PSR-0 loading $psr0Path = '/Symfony/Component/Validator/Validation.php'; if (substr($filePath, -strlen($psr0Path)) === $psr0Path) { AnnotationRegistry::registerAutoloadNamespace('Symfony\\Component\\Validator\\Constraints', substr($filePath, 0, -strlen($psr0Path))); self::$registered = true; return; } // Custom PSR-4 loader $constraintsDir = dirname($filePath) . '/Constraints/'; AnnotationRegistry::registerLoader(function ($class) use($constraintsDir) { $ns = 'Symfony\\Component\\Validator\\Constraints\\'; if (strpos($class, $ns) !== 0) { return; } $filePath = $constraintsDir . str_replace('\\', DIRECTORY_SEPARATOR, substr($class, strlen($ns))) . '.php'; if (file_exists($filePath)) { include $filePath; return true; } }); self::$registered = true; }
public function setup() { $class = new ReflectionClass('Doctrine\\ORM\\Mapping\\Annotation'); $filename = $class->getFileName(); AnnotationRegistry::registerLoader('class_exists'); AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", dirname($filename)); }
/** * @param Container|Application $app */ public function register(Container $app) { if (!$app->offsetExists('annot.useServiceControllers')) { $app['annot.useServiceControllers'] = true; } $app["annot"] = function (Container $app) { return new AnnotationService($app); }; // A custom auto loader for Doctrine Annotations since it can't handle PSR-4 directory structure AnnotationRegistry::registerLoader(function ($class) { return class_exists($class); }); // Register ServiceControllerServiceProvider here so the user doesn't have to. if ($app['annot.useServiceControllers']) { $app->register(new ServiceControllerServiceProvider()); } // this service registers the service controller and can be overridden by the user $app['annot.registerServiceController'] = $app->protect(function ($controllerName) use($app) { if ($app['annot.useServiceControllers']) { $app["{$controllerName}"] = function (Application $app) use($controllerName) { return new $controllerName($app); }; } }); $app['annot.controllerFinder'] = $app->protect(function (Application $app, $dir) { return $app['annot']->getFiles($dir, $app['annot.controllerNamespace']); }); /** @noinspection PhpUnusedParameterInspection */ $app['annot.controller_factory'] = $app->protect(function (Application $app, $controllerName, $methodName, $separator) { return $controllerName . $separator . $methodName; }); $app['annot.controllerNamespace'] = ''; }
/** * * @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator * @return object */ public function createService(ServiceLocatorInterface $serviceLocator) { $manifest = $serviceLocator->get('manifest'); $config = new Configuration(); $config->setProxyDir(__DIR__ . '/../../../../Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(__DIR__ . '/../../../../Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB(self::DEFAULT_DB); $config->setMetadataCacheImpl(new ArrayCache()); //create driver chain $chain = new MappingDriverChain(); foreach ($manifest['documents'] as $namespace => $path) { $driver = new AnnotationDriver(new AnnotationReader(), $path); $chain->addDriver($driver, $namespace); } $config->setMetadataDriverImpl($chain); //register filters foreach ($manifest['filters'] as $name => $class) { $config->addFilter($name, $class); } //create event manager $eventManager = new EventManager(); foreach ($manifest['subscribers'] as $subscriber) { $eventManager->addEventSubscriber($serviceLocator->get($subscriber)); } //register annotations AnnotationRegistry::registerLoader(function ($className) { return class_exists($className); }); $conn = new Connection(null, array(), $config); return DocumentManager::create($conn, $config, $eventManager); }
/** * Return a DIC-IT container, using adapter to respect Pyrite interface. * * @param Request $request Current request object. * @param string $containerPath Path to load config from. * * @return \Pyrite\Container\Container */ public static function build(Request $request, $containerPath) { $config = new NullConfig(); if (null !== $containerPath && preg_match('/.*yml$/', $containerPath)) { $config = new YML($containerPath); } if (null !== $containerPath && preg_match('/.*php$/', $containerPath)) { $config = new PHP($containerPath); } $activator = new ActivatorFactory(); $container = new DICITAdapter($config, $activator); $activator->addActivator('security', $container->get('SecurityActivator'), false); // initialize the translation engine $translationManager = $container->get('TranslationEngine'); $host = $request->getHttpHost(); $locale = $container->getParameter('default_locale.' . str_replace('.', '_', $host)); if ($locale === null) { $locale = $container->getParameter('default_locale.default'); } $container->setParameter('current_locale', $locale); $translationManager->setLocale($locale); $reader = new \Doctrine\Common\Annotations\AnnotationReader(); \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader(function ($class) { return class_exists($class); }); $container->bind('AnnotationReader', $reader); $director = $container->get('PyRestDirector'); $packages = $container->getParameter('crud.packages'); foreach ($packages as $packageName => $packageConfiguration) { $director->buildAll($packageName); } return $container; }
/** * @param string $userId * @param string $userPassword * @param int $partnerId * @param string $partnerPassword * @param string $errorLanguage */ public function __construct($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage) { AnnotationRegistry::registerLoader('class_exists'); $this->afterbuyGlobal = new AfterbuyGlobal($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage); $this->client = new \GuzzleHttp\Client(['base_uri' => 'https://api.afterbuy.de/afterbuy/ABInterface.aspx']); $this->serializer = Client::getDefaultSerializer(); }
public function __construct(array $dbConfig, array $options = array()) { extract($options); $entityClassLoader = new ClassLoader("Entities", $entityPath); $entityClassLoader->register(); $proxyPath = isset($proxyPath) ? $proxyPath : $entityPath; $proxyClassLoader = new ClassLoader("Proxies", $proxyPath); $proxyClassLoader->register(); $config = new Configuration(); if ($isDevMode || $isArrayCache) { $cache = new ArrayCache(); } else { $cache = new ApcCache(); } $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setProxyDir($proxyPath); $config->setProxyNamespace($namespaces["proxy"]); if (isset($isDevMode) && $isDevMode) { $config->setAutogenerateProxyClasses(true); } if (isset($driverClass) && class_exists($driverClass)) { $annotationDriver = new $driverClass($entity_driver); } else { $annotationDriver = new AnnotationDriver(new AnnotationReader(), array($entityPath)); AnnotationRegistry::registerLoader('class_exists'); } $config->setMetadataDriverImpl($annotationDriver); $this->setEntityManager($dbConfig, $config); }
public function setUp() { $loader = (require __DIR__ . '/../vendor/autoload.php'); AnnotationRegistry::registerLoader(array($loader, 'loadClass')); $reader = new AnnotationReader(); $this->annotClassLoader = new RouteAnnotationClassLoader($reader); }
public function __construct($setConfigFiles = true) { if ($setConfigFiles) { $this->configFile = __DIR__ . '/../../../config.php'; $this->localConfigFile = __DIR__ . '/../../../config.local.php'; } parent::__construct(); $isDevMode = false; $cache = new \Doctrine\Common\Cache\FilesystemCache(__DIR__ . '/../../tmp'); $config = Setup::createConfiguration($isDevMode, __DIR__ . '/../../tmp', $cache); $config->setProxyDir(__DIR__ . '/../../tmp'); $config->setProxyNamespace('MyProject\\Proxies'); $config->setAutoGenerateProxyClasses(true); $paths = [__DIR__ . '/../Entity']; $driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), $paths); \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists'); $config->setMetadataDriverImpl($driver); //$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger()); $conn = ['driver' => 'mysqli', 'host' => '127.0.0.1', 'user' => $this->databaseFactory->getUserName(), 'password' => $this->databaseFactory->getPassword(), 'dbname' => $this->databaseFactory->getDatabaseName()]; $this->entityManager = EntityManager::create($conn, $config); $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); \Doctrine\DBAL\Types\Type::addType('enum', StringType::class); $this->entityManager->getConfiguration()->addCustomStringFunction('DATE', DateFunction::class); $this->user = $this->entityManager->createQueryBuilder()->select('u')->from(Sources\Tests\Entity\User::class, 'u'); }
/** * Register's the annotation driver for the passed configuration. * * @param \AppserverIo\Appserver\Core\Api\Node\AnnotationRegistryNodeInterface $annotationRegistry The configuration node * * @return void */ public function register(AnnotationRegistryNodeInterface $annotationRegistry) { // initialize the composer class loader $classLoader = new ClassLoader(); $classLoader->addPsr4($annotationRegistry->getNamespace(), $annotationRegistry->getDirectoriesAsArray()); // register the class loader to load annotations AnnotationRegistry::registerLoader(array($classLoader, 'loadClass')); }
/** * @param Reader $annotationReader */ public function __construct(Reader $annotationReader) { AnnotationRegistry::registerLoader(function ($class) { return class_exists($class); }); $this->annotationReader = $annotationReader; $this->reflectionTools = new ReflectionTools(); }
/** * Constructor * * @param string $sourcePath * @param string $generationPath */ public function __construct($sourcePath, $generationPath) { AnnotationRegistry::registerLoader(function ($className) { return class_exists($className); }); $this->sourcePath = $sourcePath; $this->generationPath = $generationPath; }