/**
* Replaces default DateTime Doctrine types with their _immutable counterparts
*/
public static function replaceImmutableTypes()
{
Type::overrideType(Type::DATE, DateTimeImmutable\DateImmutableType::class);
Type::overrideType(Type::DATETIME, DateTimeImmutable\DateTimeImmutableType::class);
Type::overrideType(Type::DATETIMETZ, DateTimeImmutable\DateTimeTzImmutableType::class);
Type::overrideType(Type::TIME, DateTimeImmutable\TimeImmutableType::class);
}
/**
* @param array $options
* @param \Zend_Cache_Core $cache
* @param \Enlight_Hook_HookManager $hookManager
*/
public function __construct($options, \Zend_Cache_Core $cache, \Enlight_Hook_HookManager $hookManager)
{
$this->setHookManager($hookManager);
// Specifies the FQCN of a subclass of the EntityRepository.
// That will be available for all entities without a custom repository class.
$this->setDefaultRepositoryClassName('Shopware\\Components\\Model\\ModelRepository');
$this->setProxyDir($options['proxyDir']);
$this->setProxyNamespace($options['proxyNamespace']);
$this->setAutoGenerateProxyClasses(AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS);
$this->setAttributeDir($options['attributeDir']);
$this->setFileCacheDir($options['fileCacheDir']);
$this->addEntityNamespace('Shopware', 'Shopware\\Models');
$this->addEntityNamespace('Custom', 'Shopware\\CustomModels');
Type::overrideType('datetime', 'Shopware\\Components\\Model\\DBAL\\Types\\DateTimeStringType');
Type::overrideType('date', 'Shopware\\Components\\Model\\DBAL\\Types\\DateStringType');
Type::overrideType('array', 'Shopware\\Components\\Model\\DBAL\\Types\\AllowInvalidArrayType');
$this->addCustomStringFunction('DATE_FORMAT', 'Shopware\\Components\\Model\\Query\\Mysql\\DateFormat');
$this->addCustomStringFunction('IFNULL', 'Shopware\\Components\\Model\\Query\\Mysql\\IfNull');
$this->addCustomStringFunction('RegExp', 'Shopware\\Components\\Model\\Query\\Mysql\\RegExp');
$this->addCustomStringFunction('Replace', 'Shopware\\Components\\Model\\Query\\Mysql\\Replace');
// Load custom namespace for doctrine cache provider, if provided
if (isset($options['cacheNamespace'])) {
$this->cacheNamespace = $options['cacheNamespace'];
}
if (isset($options['cacheProvider'])) {
$this->setCacheProvider($options['cacheProvider']);
}
if ($this->getMetadataCacheImpl() === null) {
$this->setCacheResource($cache);
}
}
protected function setUp()
{
if (Type::hasType(ExtendedDataType::NAME)) {
Type::overrideType(ExtendedDataType::NAME, 'JMS\\Payment\\CoreBundle\\Entity\\ExtendedDataType');
} else {
Type::addType(ExtendedDataType::NAME, 'JMS\\Payment\\CoreBundle\\Entity\\ExtendedDataType');
}
}
public function setUp()
{
if (Type::hasType('json')) {
Type::overrideType('json', 'Sonata\\Doctrine\\Types\\JsonType');
} else {
Type::addType('json', 'Sonata\\Doctrine\\Types\\JsonType');
}
}
/**
* @param $name
* @param $class
*
* @throws \Doctrine\DBAL\DBALException
*/
public function addType($name, $class)
{
if (!Type::hasType($name)) {
Type::addType($name, $class);
} else {
Type::overrideType($name, $class);
}
}
public function setUp()
{
if (Type::hasType('currency')) {
Type::overrideType('currency', 'Sonata\\Component\\Currency\\CurrencyDoctrineType');
} else {
Type::addType('currency', 'Sonata\\Component\\Currency\\CurrencyDoctrineType');
}
}
protected function setUp()
{
if (DBALType::hasType('negative_to_positive')) {
DBALType::overrideType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
} else {
DBALType::addType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
}
$this->_em = $this->_getTestEntityManager();
}
/**
* Configures DBAL types required in tests
*/
protected function setUpDBALTypes()
{
if (Type::hasType('jsonb')) {
Type::overrideType('jsonb', 'Boldtrn\\JsonbBundle\\Types\\JsonbArrayType');
} else {
Type::addType('jsonb', 'Boldtrn\\JsonbBundle\\Types\\JsonbArrayType');
}
$this->connection->getDatabasePlatform()->registerDoctrineTypeMapping('JSONB', 'jsonb');
}
protected function setUp()
{
$this->generator = \Mockery::mock(EnumTypeGenerator::class);
$this->storage = \Mockery::mock(EnumTypeStorage::class);
$this->sut = new EnumTypeRegistry($this->generator, $this->storage);
if (Type::hasType('foobar')) {
Type::overrideType('foobar', null);
}
}
public function boot()
{
// Register custom data types
if (!Type::hasType('uniqueidentifier')) {
Type::addType('uniqueidentifier', 'Realestate\\MssqlBundle\\Types\\UniqueidentifierType');
}
Type::overrideType('date', 'Realestate\\MssqlBundle\\Types\\DateType');
Type::overrideType('datetime', 'Realestate\\MssqlBundle\\Types\\DateTimeType');
}
private function initializeTypes()
{
foreach ($this->typesConfig as $type => $className) {
if (Type::hasType($type)) {
Type::overrideType($type, $className);
} else {
Type::addType($type, $className);
}
}
}
protected function setUp()
{
if (DBALType::hasType(CustomIdObjectType::NAME)) {
DBALType::overrideType(CustomIdObjectType::NAME, CustomIdObjectType::CLASSNAME);
} else {
DBALType::addType(CustomIdObjectType::NAME, CustomIdObjectType::CLASSNAME);
}
$this->useModelSet('custom_id_object_type');
parent::setUp();
}
public function setUp()
{
// Type is a singleton.
if (Type::hasType(self::TYPE_NAME)) {
// Remove the type so it can be re-instantiated.
Type::overrideType(self::TYPE_NAME, null);
}
Type::addType(self::TYPE_NAME, 'Omeka\\Db\\Type\\IpAddress');
$this->ipAddress = Type::getType(self::TYPE_NAME);
$this->platform = $this->getMockForAbstractClass('Doctrine\\DBAL\\Platforms\\AbstractPlatform');
}
/**
* {@inheritDoc}
*/
public function __construct()
{
parent::__construct();
$this->initializeDoctrineTypeMappings();
if (!Type::hasType(MapType::NAME)) {
Type::addType(MapType::NAME, 'Crate\\DBAL\\Types\\MapType');
}
if (!Type::hasType(TimestampType::NAME)) {
Type::addType(TimestampType::NAME, 'Crate\\DBAL\\Types\\TimestampType');
}
Type::overrideType('array', 'Crate\\DBAL\\Types\\ArrayType');
}
public function testSerialization()
{
$array = array('a' => 'b');
$encoded = base64_encode(serialize($array));
$platform = TestUtil::getEntityManager()->getConnection()->getDatabasePlatform();
Type::overrideType(Type::TARRAY, 'Oro\\DBAL\\Types\\ArrayType');
$type = Type::getType(Type::TARRAY);
$actualDbValue = $type->convertToDatabaseValue($array, $platform);
$this->assertEquals($encoded, $actualDbValue);
$this->assertEquals($array, $type->convertToPHPValue($actualDbValue, $platform));
$this->assertEquals($array, $type->convertToPHPValue($encoded, $platform));
}
/**
* initialize the types
*/
private function initializeTypes()
{
foreach ($this->typesConfig as $type => $typeConfig) {
if (Type::hasType($type)) {
Type::overrideType($type, $typeConfig['class']);
} else {
Type::addType($type, $typeConfig['class']);
}
if ($typeConfig['commented']) {
$this->commentedTypes[] = $type;
}
}
}
/**
* @param ServiceLocatorInterface $serviceLocator
* @param Configuration $config
*/
public function setupDBALConfiguration(ServiceLocatorInterface $serviceLocator, Configuration $config)
{
$options = $this->getOptions($serviceLocator);
$config->setResultCacheImpl($serviceLocator->get($options->resultCache));
$config->setSQLLogger($options->sqlLogger);
foreach ($options->types as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
}
public function testSerialization()
{
$object = new \stdClass();
$object->a = 'test1';
$encoded = base64_encode(serialize($object));
$platform = TestUtil::getEntityManager()->getConnection()->getDatabasePlatform();
Type::overrideType(Type::OBJECT, 'Oro\\DBAL\\Types\\ObjectType');
$type = Type::getType(Type::OBJECT);
$actualDbValue = $type->convertToDatabaseValue($object, $platform);
$this->assertEquals($encoded, $actualDbValue);
$this->assertEquals($object, $type->convertToPHPValue($actualDbValue, $platform));
$this->assertEquals($object, $type->convertToPHPValue($encoded, $platform));
}
function register_dbal_types()
{
$types = ['coast_url' => 'Coast\\Doctrine\\DBAL\\Types\\UrlType'];
foreach ($types as $name => $class) {
\Doctrine\DBAL\Types\Type::addType($name, $class);
}
if (class_exists('Carbon\\Carbon')) {
$types = ['date' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonDateType', 'time' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonTimeType', 'datetime' => 'Coast\\Doctrine\\DBAL\\Types\\CarbonDateTimeType'];
foreach ($types as $name => $class) {
\Doctrine\DBAL\Types\Type::overrideType($name, $class);
}
}
}
public function boot()
{
// Register custom data types
if (!Type::hasType('uniqueidentifier')) {
Type::addType('uniqueidentifier', 'Improvein\\MssqlBundle\\Types\\UniqueidentifierType');
}
if (!Type::hasType('geography')) {
Type::addType('geography', 'Improvein\\MssqlBundle\\Types\\PointType');
}
Type::overrideType(Type::DATE, 'Improvein\\MssqlBundle\\Types\\DateType');
Type::overrideType(Type::DATETIME, 'Improvein\\MssqlBundle\\Types\\DateTimeType');
Type::overrideType(Type::TEXT, 'Improvein\\MssqlBundle\\Types\\TextType');
Type::overrideType(Type::STRING, 'Improvein\\MssqlBundle\\Types\\StringType');
}
/**
* @param Configuration $ormConfiguration
* @param Config $dbConfig
* @return EntityManager
*/
public static function configure($dbConfig, Configuration $ormConfiguration)
{
Type::overrideType("datetime", 'Doctrine\\DBAL\\Types\\VarDateTimeType');
//новый биллинг семь знаков после секунды
$ormConfiguration->setProxyDir(__DIR__ . '/Proxy');
$ormConfiguration->setProxyNamespace('Billing\\Proxy');
//$config->setSQLLogger(new Core\HtmlSqlLogger());
$eventManager = new \Doctrine\Common\EventManager();
$eventManager->addEventSubscriber(new \Doctrine\DBAL\Event\Listeners\SQLSessionInit('use billing35;'));
//?$eventManager->addEventSubscriber($loggableListener);
//dblib:host=217.114.191.214;dbname=planneddebtorsrollcall;','obzvon','qwerty123!
$dbConfig = array("driver" => "pdo_sqlsrv", "user" => $dbConfig->user, "password" => $dbConfig->password, "host" => strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ? "217.114.191.214" : "ipsoft", "dbname" => $dbConfig->database, "driverOptions" => array("CharacterSet" => "UTF-8"));
self::$_em = EntityManager::create($dbConfig, $ormConfiguration, $eventManager);
return self::$_em;
}
/**
* Add a type.
*
* @param string $name
* @param string $className
* @param callable[] $calls an array of - [ methodName, [ methodParams... ] ]
*/
public function addType($name, $className, array $calls = [])
{
if (!Type::hasType($name)) {
Type::addType($name, $className);
} else {
Type::overrideType($name, $className);
}
if (!empty($calls)) {
$type = self::getType($name);
foreach ($calls as $call) {
call_user_func_array([$type, $call[0]], $call[1]);
}
}
$this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($name, $name);
}
protected function setUp()
{
if (DBALType::hasType('upper_case_string')) {
DBALType::overrideType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType');
} else {
DBALType::addType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType');
}
if (DBALType::hasType('negative_to_positive')) {
DBALType::overrideType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
} else {
DBALType::addType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
}
$this->useModelSet('customtype');
parent::setUp();
}
protected function setUp()
{
parent::setUp();
if (DBALType::hasType('negative_to_positive')) {
DBALType::overrideType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
} else {
DBALType::addType('negative_to_positive', '\\Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
}
if (DBALType::hasType('upper_case_string')) {
DBALType::overrideType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType');
} else {
DBALType::addType('upper_case_string', '\\Doctrine\\Tests\\DbalTypes\\UpperCaseStringType');
}
$this->_em = $this->_getTestEntityManager();
$this->_persister = new BasicEntityPersister($this->_em, $this->_em->getClassMetadata("Doctrine\\Tests\\Models\\CustomType\\CustomTypeParent"));
}
/**
* @param ContainerInterface $container
* @param Configuration $config
*/
public function setupDBALConfiguration(ContainerInterface $container, Configuration $config)
{
$options = $this->getOptions($container);
$config->setResultCacheImpl($container->get($options->resultCache));
$sqlLogger = $options->sqlLogger;
if (is_string($sqlLogger) and $container->has($sqlLogger)) {
$sqlLogger = $container->get($sqlLogger);
}
$config->setSQLLogger($sqlLogger);
foreach ($options->types as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
}
/**
* Registers all declared typed, if not already done.
*
* @param ContainerInterface $container
*/
private function registerTypes(ContainerInterface $container)
{
if (self::$areTypesRegistered) {
return;
}
$applicationConfig = $container->has('config') ? $container->get('config') : [];
$doctrineConfig = array_key_exists('doctrine', $applicationConfig) ? $applicationConfig['doctrine'] : [];
$typesConfig = array_key_exists('types', $doctrineConfig) ? $doctrineConfig['types'] : [];
foreach ($typesConfig as $name => $className) {
if (Type::hasType($name)) {
Type::overrideType($name, $className);
continue;
}
Type::addType($name, $className);
}
self::$areTypesRegistered = true;
}
public static function init($options)
{
if (empty($options)) {
return false;
}
// Register custom data types.
Type::addType('json', 'DF\\Doctrine\\Type\\Json');
Type::addType('unixdatetime', 'DF\\Doctrine\\Type\\UnixDateTime');
Type::overrideType('array', 'DF\\Doctrine\\Type\\SoftArray');
Type::overrideType('datetime', 'DF\\Doctrine\\Type\\UTCDateTime');
// Fetch and store entity manager.
$em = self::getEntityManager($options);
$conn = $em->getConnection();
$platform = $conn->getDatabasePlatform();
$platform->markDoctrineTypeCommented(Type::getType('json'));
$platform->markDoctrineTypeCommented(Type::getType('unixdatetime'));
return $em;
}
public function onBootstrap(Event $e)
{
$application = $e->getApplication();
$eventManager = $application->getEventManager();
$eventManager->attach(MvcEvent::EVENT_DISPATCH, array($this, 'setApplicationSection'));
$eventManager->attach(MvcEvent::EVENT_DISPATCH, array($this, 'setLayout'), 31);
$eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, array($this, 'setLayout'), 31);
$app = $e->getParam('application');
$sm = $app->getServiceManager();
$evm = $sm->get('doctrine.eventmanager.orm_default');
$config = $sm->get('Config');
$tablePrefix = isset($config['doctrine']['connection']['orm_default']['params']['table_prefix']) ? $config['doctrine']['connection']['orm_default']['params']['table_prefix'] : FALSE;
if ($tablePrefix) {
$tablePrefix = new \Dxapp\Doctrine\Extension\TablePrefix($tablePrefix);
$evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $tablePrefix);
}
$cache = $sm->get('doctrine.cache.memcache');
$annotationReader = new \Doctrine\Common\Annotations\AnnotationReader();
$cachedAnnotationReader = new \Doctrine\Common\Annotations\CachedReader($annotationReader, $cache);
$em = $sm->get('doctrine.entitymanager.orm_default');
\Doctrine\DBAL\Types\Type::overrideType('datetime', 'Dxapp\\Doctrine\\Types\\UTCDatetimeType');
// $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('Datetime', 'datetime');
$sluggableListener = new \Gedmo\Sluggable\SluggableListener();
$sluggableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($sluggableListener);
$treeListener = new \Gedmo\Tree\TreeListener();
$treeListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($treeListener);
$timestampableListener = new \Gedmo\Timestampable\TimestampableListener();
$timestampableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($timestampableListener);
$translatableListener = new \Gedmo\Translatable\TranslatableListener();
$translatableListener->setAnnotationReader($cachedAnnotationReader);
$translatableListener->setTranslatableLocale('en');
$translatableListener->setDefaultLocale('en');
$evm->addEventSubscriber($translatableListener);
}
/**
* Connect to the database sets the entity manager.
*
* @param array $params
* @param string $sysPath
* @param string $entityRootPath
*
* @throws \Doctrine\ORM\ORMException
*/
public function connect($params = array(), $sysPath = '', $entityRootPath = '')
{
$config = self::getDoctrineConfig($entityRootPath);
$config->setAutoGenerateProxyClasses(true);
$config->setEntityNamespaces(array('ChamiloUserBundle' => 'Chamilo\\UserBundle\\Entity', 'ChamiloCoreBundle' => 'Chamilo\\CoreBundle\\Entity', 'ChamiloCourseBundle' => 'Chamilo\\CourseBundle\\Entity'));
$params['charset'] = 'utf8';
$entityManager = EntityManager::create($params, $config);
$sysPath = !empty($sysPath) ? $sysPath : api_get_path(SYS_PATH);
// Registering Constraints
AnnotationRegistry::registerAutoloadNamespace('Symfony\\Component\\Validator\\Constraint', $sysPath . "vendor/symfony/symfony/src");
AnnotationRegistry::registerFile($sysPath . "vendor/symfony/symfony/src/Symfony/Bridge/Doctrine/Validator/Constraints/UniqueEntity.php");
// Registering gedmo extensions
AnnotationRegistry::registerAutoloadNamespace('Gedmo\\Mapping\\Annotation', $sysPath . "vendor/gedmo/doctrine-extensions/lib");
Type::overrideType(Type::DATETIME, self::getUTCDateTimeTypeClass());
$listener = new \Gedmo\Timestampable\TimestampableListener();
$entityManager->getEventManager()->addEventSubscriber($listener);
$listener = new \Gedmo\Tree\TreeListener();
$entityManager->getEventManager()->addEventSubscriber($listener);
$listener = new \Gedmo\Sortable\SortableListener();
$entityManager->getEventManager()->addEventSubscriber($listener);
$connection = $entityManager->getConnection();
$this->setConnection($connection);
$this->setManager($entityManager);
}
public function testCustomTypeValueSqlForPartialObject()
{
if (DBALType::hasType('negative_to_positive')) {
DBALType::overrideType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
} else {
DBALType::addType('negative_to_positive', 'Doctrine\\Tests\\DbalTypes\\NegativeToPositiveType');
}
$this->assertSqlGeneration('SELECT partial p.{id, customInteger} FROM Doctrine\\Tests\\Models\\CustomType\\CustomTypeParent p', 'SELECT c0_.id AS id0, -(c0_.customInteger) AS customInteger1 FROM customtype_parents c0_');
}
