/**
* {@inheritdoc}
*/
public function boot(Application $app)
{
if (!isset($app['db.event_manager'])) {
throw new FatalErrorException('The DoctrineServiceProvider is not registered in this application');
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_SLUGGABLE') === true) {
$listener = new SluggableListener();
$app['db.event_manager']->addEventSubscriber($listener);
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_TREE') === true) {
$listener = new TreeListener();
$app['db.event_manager']->addEventSubscriber($listener);
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_LOGGABLE') === true) {
$listener = new LoggableListener();
$app['db.event_manager']->addEventSubscriber($listener);
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_TIMESTAMPABLE') === true) {
$listener = new TimestampableListener();
$app['db.event_manager']->addEventSubscriber($listener);
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_TRANSLATABLE') === true) {
$listener = new TranslatableListener();
if (!isset($app['translator'])) {
throw new FatalErrorException('The TranslationServiceProvider is not registered in this application');
}
$listener->setTranslatableLocale($app['translator']->getLocale());
$listener->setDefaultLocale($app['translator']->getLocale());
$app['db.event_manager']->addEventSubscriber($listener);
}
if (Environment::get('DOCTRINE_EXTENSION_ENABLE_SORTABLE') === true) {
$listener = new SortableListener();
$app['db.event_manager']->addEventSubscriber($listener);
}
}
/**
* @param EventManager $manager
* @param EntityManagerInterface $em
* @param Reader $reader
*/
public function addSubscribers(EventManager $manager, EntityManagerInterface $em, Reader $reader = null)
{
$subscriber = new TranslatableListener();
$subscriber->setTranslatableLocale($this->application->getLocale());
$subscriber->setDefaultLocale($this->repository->get('app.locale'));
$this->addSubscriber($subscriber, $manager, $reader);
}
/**
* @param GetResponseEvent $event
*/
public function onLateKernelRequest(GetResponseEvent $event)
{
if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType() or !in_array($this->kernel->getEnvironment(), array('admin', 'admin_dev'))) {
return;
}
$this->translationListener->setTranslatableLocale($this->context->getDefaultFrontLocale());
}
public function create()
{
$listener = new TranslatableListener();
$listener->setDefaultLocale($this->defaultLocale);
$listener->setTranslatableLocale($this->locale);
return $listener;
}
/**
* @param GetResponseEvent $event
*/
public function onLateKernelRequest(GetResponseEvent $event)
{
$request = $event->getRequest();
$locale = $this->context->get('language');
$request->setLocale($locale);
$this->translationListener->setTranslatableLocale($locale);
}
/**
* @param HttpRequest $request
* @param string $locale
*/
public function setLocale(HttpRequest $request, $locale)
{
setlocale(LC_ALL, $locale);
$locale = substr($locale, 0, 2);
$request->setLocale($locale);
$this->translator->setLocale($locale);
$this->translatable->setTranslatableLocale($locale);
}
public function onLateKernelRequest(GetResponseEvent $event)
{
$site = $this->siteSelector->retrieve();
if ($site) {
$this->translatableListener->setTranslatableLocale($site->getLocale());
$this->translatableListener->setFallbackLocales($site->getLocales());
}
}
/**
* @param GetResponseEvent $event
*/
public function onKernelRequest(GetResponseEvent $event)
{
$request = $event->getRequest();
$locale = str_replace('-', '_', $request->query->get('locale'));
if ($locale && $this->isApiRequest($request)) {
$request->setLocale($locale);
$this->translatableListener->setTranslatableLocale($locale);
}
}
/**
* {@inheritdoc}
*/
protected function getPropertyHolder($subject, $language, $activity = null)
{
$listenerLocale = $this->listener->getListenerLocale();
if ($listenerLocale !== $language) {
$subject->setLocale($language);
$this->getManager($subject)->refresh($subject);
}
return $subject;
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$translatableListener = new TranslatableListener();
$translatableListener->setTranslatableLocale('en_US');
$evm->addEventSubscriber($translatableListener);
$evm->addEventSubscriber(new TimestampableListener());
$this->getMockSqliteEntityManager($evm);
}
public function register(Container $c)
{
$c['doctrine_extensions.translatable.listener'] = function ($c) {
$listener = new TranslatableListener();
$listener->setTranslatableLocale($c['locale']);
$listener->setDefaultLocale($c['locale']);
$listener->setAnnotationReader($c['annotation.reader']);
return $listener;
};
}
public function testOnKernelRequest()
{
$customLocale = 'fr';
$request = new Request(['locale' => $customLocale]);
$request->server->set('REQUEST_URI', '/api/rest/test');
$request->setDefaultLocale($this->defaultLocale);
$translationListener = new TranslatableListener();
$this->listener = new LocaleListener($translationListener);
$this->listener->onKernelRequest($this->createGetResponseEvent($request));
$this->assertEquals($customLocale, $request->getLocale());
$this->assertEquals($customLocale, $translationListener->getListenerLocale());
}
/**
* {@inheritdoc}
*/
protected function configureFormFields(FormMapper $formMapper)
{
$block = $this->getSubject();
if ($block->getId() === null) {
// new block
$service = $this->blockManager->getService($this->request->get('type'));
$block->setName($service->getName());
}
$this->translatableListener->setTranslatableLocale($block->getSite()->getDefaultLocale());
$this->translatableListener->setFallbackLocales($block->getSite()->getLocales());
return parent::configureFormFields($formMapper);
}
/**
* @test
*/
public function testQueryWalker()
{
$dql = 'SELECT f FROM ' . self::FIXTURE . ' f';
$q = $this->em->createQuery($dql);
$q->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, self::TREE_WALKER_TRANSLATION);
$this->translatableListener->setTranslatableLocale('de');
$result = $q->getArrayResult();
$this->assertCount(1, $result);
$this->assertSame('test-de', $result[0]['title']);
$this->assertSame('website-de', $result[0]['link.website']);
$this->assertSame('facebook-de', $result[0]['link.facebook']);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$translatableListener = new TranslatableListener();
$translatableListener->setTranslatableLocale('en_US');
$evm->addEventSubscriber($translatableListener);
$blameableListener = new BlameableListener();
$blameableListener->setUserValue('testuser');
$evm->addEventSubscriber($blameableListener);
$this->getMockSqliteEntityManager($evm);
}
public function testTranslatableMetadata()
{
$meta = $this->em->getClassMetadata('Mapping\\Fixture\\Xml\\Translatable');
$config = $this->translatable->getConfiguration($this->em, $meta->name);
$this->assertArrayHasKey('translationClass', $config);
$this->assertEquals('Gedmo\\Translatable\\Entity\\Translation', $config['translationClass']);
$this->assertArrayHasKey('locale', $config);
$this->assertEquals('locale', $config['locale']);
$this->assertArrayHasKey('fields', $config);
$this->assertCount(2, $config['fields']);
$this->assertTrue(in_array('title', $config['fields']));
$this->assertTrue(in_array('content', $config['fields']));
}
/**
* @dataProvider getLocales
*
* @param string $locale
*/
public function testSetLocale($locale)
{
$expected = substr($locale, 0, 2);
/* @var $request \PHPUnit_Framework_MockObject_MockObject|HttpRequest */
$request = $this->getMockBuilder('\\Symfony\\Component\\HttpFoundation\\Request')->disableOriginalConstructor()->getMock();
$request->expects($this->once())->method('setLocale')->with($expected);
$this->translator->expects($this->once())->method('setLocale')->with($expected);
$this->translatable->expects($this->once())->method('setTranslatableLocale')->with($expected);
$this->listener->setLocale($request, $locale);
}
/**
* @param ConsoleCommandEvent $event
*/
public function onConsoleCommand(ConsoleCommandEvent $event)
{
$isForced = $event->getInput()->hasParameterOption('--force');
if ($isForced) {
$this->isInstalled = false;
return;
}
if ($this->isInstalled) {
try {
$locale = $this->localeSettings->getLocale();
$language = $this->localeSettings->getLanguage();
} catch (DBALException $exception) {
// application is not installed
return;
}
$this->setPhpDefaultLocale($locale);
$this->translatableListener->setTranslatableLocale($language);
}
}
private function populate()
{
$repo = $this->em->getRepository(self::ARTICLE);
$commentRepo = $this->em->getRepository(self::COMMENT);
$food = new Article();
$food->setTitle('Food');
$food->setContent('about food');
$food->setAuthor('John Doe');
$food->setViews(99);
$goodFood = new Comment();
$goodFood->setArticle($food);
$goodFood->setMessage('food is good');
$goodFood->setSubject('good');
$badFood = new Comment();
$badFood->setArticle($food);
$badFood->setMessage('food is bad');
$badFood->setSubject('bad');
$this->em->persist($food);
$this->em->persist($goodFood);
$this->em->persist($badFood);
$this->em->flush();
$this->em->clear();
$this->translatableListener->setTranslatableLocale('lt_lt');
$food = $repo->find(1);
$food->setTitle('Maistas');
$food->setContent('apie maista');
$food->setViews(999);
$goodFood = $commentRepo->find(1);
$goodFood->setArticle($food);
$goodFood->setMessage('maistas yra geras');
$goodFood->setSubject('geras');
$badFood = $commentRepo->find(2);
$badFood->setArticle($food);
$badFood->setMessage('maistas yra blogas');
$badFood->setSubject('blogas');
$this->em->persist($food);
$this->em->persist($goodFood);
$this->em->persist($badFood);
$this->em->flush();
$this->em->clear();
}
/**
* {@inheritDoc}
*/
public function loadClassMetadata(EventArgs $eventArgs)
{
$ea = $this->getEventAdapter($eventArgs);
$meta = $eventArgs->getClassMetadata();
$name = $meta->getName();
if (isset($this->translations[$name])) {
$ea->mapTranslation($meta, $this->translations[$name]);
unset($this->translations[$name]);
return;
}
parent::loadClassMetadata($eventArgs);
if (isset(static::$configurations[$this->name][$name])) {
if ($name === $ea->getRootObjectClass($meta)) {
$translationClass = static::$configurations[$this->name][$name]['translationClass'];
$this->translations[$translationClass] = $name;
// load translation class metadata if not loaded yet
$ea->getObjectManager()->getClassMetadata($translationClass);
$ea->mapTranslatable($meta, $translationClass);
}
}
}
/**
* Makes additional translation of $entity $field into $locale using $value
*
* @param object $entity
* @param string $field
* @param string $locale
* @param mixed $value
*
* @return TranslationRepository
* @access public
* @author Etienne de Longeaux <*****@*****.**>
*/
public function translate($entity, $field, $locale, $value)
{
$meta = $this->_em->getClassMetadata(get_class($entity));
$listener = new \Gedmo\Translatable\TranslatableListener();
//$this->getTranslatableListener();
$config = $listener->getConfiguration($this->_em, $meta->name);
if (!isset($config['fields']) || !in_array($field, $config['fields'])) {
throw new \Gedmo\Exception\InvalidArgumentException("Entity: {$meta->name} does not translate field - {$field}");
}
if (in_array($locale, array($listener->getDefaultLocale(), $listener->getTranslatableLocale($entity, $meta)))) {
$meta->getReflectionProperty($field)->setValue($entity, $value);
$this->_em->persist($entity);
} else {
$ea = new TranslatableAdapterORM();
$foreignKey = $meta->getReflectionProperty($meta->getSingleIdentifierFieldName())->getValue($entity);
$objectClass = $meta->name;
$class = $listener->getTranslationClass($ea, $meta->name);
$transMeta = $this->_em->getClassMetadata($class);
$trans = $this->findOneBy(compact('locale', 'field', 'object'));
if (!$trans) {
$trans = new $class();
$transMeta->getReflectionProperty('object')->setValue($trans, $entity->getId());
$transMeta->getReflectionProperty('field')->setValue($trans, $field);
$transMeta->getReflectionProperty('locale')->setValue($trans, $locale);
}
$type = Type::getType($meta->getTypeOfField($field));
$transformed = $type->convertToDatabaseValue($value, $this->_em->getConnection()->getDatabasePlatform());
$transMeta->getReflectionProperty('content')->setValue($trans, $transformed);
if ($this->_em->getUnitOfWork()->isInIdentityMap($entity)) {
$this->_em->persist($trans);
} else {
$oid = spl_object_hash($entity);
$listener->addPendingTranslationInsert($oid, $trans);
}
}
return $this;
// $meta = $this->_em->getClassMetadata(get_class($entity));
// $listener = $this->getTranslatableListener();
// $config = $listener->getConfiguration($this->_em, $meta->name);
// if (!isset($config['fields']) || !in_array($field, $config['fields'])) {
// throw new \Gedmo\Exception\InvalidArgumentException("Entity: {$meta->name} does not translate field - {$field}");
// }
// $ea = new TranslatableAdapterORM();
// $class = $listener->getTranslationClass($ea, $meta->name);
// $trans = $this->findOneBy(compact('locale', 'field', 'object_id'));
// if (!$trans) {
// $entity->setTranslatableLocale('fr');
// $entity->addTranslation(new $class($locale, $field, $value));
// }
// $this->_em->persist($entity);
// $this->_em->flush();
}
/**
* Gets Gedmo default locale
*
* @return string
*/
public function getDefaultLocale()
{
return $this->gedmoTranslatableListener->getDefaultLocale();
}
/**
* @param string $locale
*/
public function setTranslatableLocale($locale = 'en_US')
{
$this->translatableListener->setTranslatableLocale($locale);
}
public function onConsoleCommand()
{
setlocale(LC_ALL, $this->locale);
$this->translator->setLocale($this->locale);
$this->translatable->setTranslatableLocale(substr($this->locale, 0, 2));
}
public function testTranslatableMetadataWithEmbedded()
{
$meta = $this->em->getClassMetadata('Mapping\\Fixture\\Xml\\TranslatableWithEmbedded');
$config = $this->translatable->getConfiguration($this->em, $meta->name);
$this->assertContains('embedded.subtitle', $config['fields']);
}
