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;
}
