/** * @param EventArgs $args * @return mixed|void */ public function onFlush(EventArgs $args) { $em = $args->getEntityManager(); $unitOfWork = $em->getUnitOfWork(); foreach ($unitOfWork->getScheduledEntityUpdates() as $entity) { if ($entity instanceof PageInterface) { if ($contentRoute = $entity->getContentRoute()) { $contentRoute->setPath(PageHelper::getPageRoutePath($entity->getPath())); $em->persist($contentRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($contentRoute)), $contentRoute); foreach ($entity->getAllChildren() as $child) { $contentRoute = $child->getContentRoute(); $contentRoute->setPath(PageHelper::getPageRoutePath($child->getPath())); $em->persist($contentRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($contentRoute)), $contentRoute); if ($entity->getStatus() == Page::STATUS_PUBLISHED) { if ($childSnapshot = $child->getSnapshot()) { $snapshotRoute = $childSnapshot->getContentRoute(); $newPath = PageHelper::getPageRoutePath($child->getPath()); $snapshotRoute->setPath($newPath); $childSnapshot->setPath($newPath); $em->persist($childSnapshot); $em->persist($snapshotRoute); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($childSnapshot)), $childSnapshot); $unitOfWork->computeChangeSet($em->getClassMetadata(get_class($snapshotRoute)), $snapshotRoute); } } } } } } }
/** * @param EventArgs $args */ public function prePersist(EventArgs $args) { $em = $args->getEntityManager(); $entity = $args->getEntity(); if ($entity instanceof InstanceInterface && !$entity->getInstance() && ($tenant = $em->getTenant())) { $entity->setTenant($tenant); } }
/** * @param \Doctrine\ORM\Event\LifecycleEventArgs $args * * @return \Sonata\MediaBundle\Provider\MediaProviderInterface */ protected function getProvider(EventArgs $args) { $media = $args->getEntity(); if (!$media instanceof MediaInterface) { return null; } return $this->getPool()->getProvider($media->getProviderName()); }
/** * @param EventArgs $eventArgs * @return void */ public function loadClassMetadata(EventArgs $eventArgs) { $meta = $eventArgs->getClassMetadata(); $ea = $this->getEventAdapter($eventArgs); if (is_subclass_of($meta->getName(), $ea->getHierarchyClassName(), true)) { $ea->mapHierarchy($meta); } parent::loadClassMetadata($eventArgs); }
/** * @param EventArgs $args * @param string $method * @return mixed|void */ public function getLoggingInfo(EventArgs $args, $method = '') { $entity = $args->getEntity(); if ($this->getSecurityContext()->getToken() && $this->getSecurityContext()->getToken()->getUser() != 'anon.') { $username = $this->getSecurityContext()->getToken()->getUser()->getUsername(); } else { $username = '******'; } $this->logger->info(sprintf('entity %s', $method), array('username' => $username, 'class' => get_class($entity), 'id' => $entity->getId())); }
/** * @param EventArgs $args * @param string $method * @return mixed|void */ public function getLoggingInfo(EventArgs $args, $method = '') { $entity = $args->getEntity(); if ($this->getTokenStorage()->getToken() && $this->getTokenStorage()->getToken()->getUser() != 'anon.') { $username = $this->getTokenStorage()->getToken()->getUser()->getUsername(); } else { $username = '******'; } $id = method_exists($entity, 'getId') ? $entity->getId() : null; $this->logger->info(sprintf('entity %s', $method), array('username' => $username, 'class' => get_class($entity), 'id' => $id)); }
/** * @inheritdoc */ protected function getMedia(EventArgs $args) { $media = $args->getEntity(); if (!$media instanceof MediaInterface) { return $media; } if (!$media->getCategory()) { $media->setCategory($this->getRootCategory($media)); } return $media; }
/** * @param EventArgs $eventArgs */ public function loadClassMetadata(EventArgs $eventArgs) { $meta = $eventArgs->getClassMetadata(); if (!$meta->isRootEntity() || $meta->isInheritanceTypeNone() || $meta->subClasses || $meta->isMappedSuperclass) { return; } $ea = $this->getEventAdapter($eventArgs); $om = $ea->getObjectManager(); $name = $meta->getName(); $meta->subClasses = $this->getSubClasses($name, $om); $this->loadMetadataForObjectClass($om, $meta); }
/** * Registered the postLoad calls for wanted classes * * @param EventArgs $event * @access public * @return void */ public function loadClassMetadata(EventArgs $event) { if ($event instanceof LoadClassMetadataEventArgs) { $className = $event->getClassMetadata()->getName(); $this->loadExternalAssociationByClassName($className); } elseif (method_exists($event, 'getObjectManager')) { $this->loadExternalAssociationByManager($event->getObjectManager()); } else { $msg = '$event must implements `Doctrine\\Common\\Persistence\\Event\\LoadClassMetadataEventArgs` ' . ' or have a `getObjectManager` method.'; throw new \InvalidArgumentException($msg); } }
/** * @param EventArgs $args * @return mixed|void */ public function preUpdate(EventArgs $args) { $entity = $args->getEntity(); $em = $args->getEntityManager(); $uow = $em->getUnitOfWork(); if ($entity instanceof ContentRoute) { $template = $this->templates[$entity->getTemplateName()]; $changeset = $uow->getEntityChangeSet($entity); if (isset($changeset['templateName']) && $args->hasChangedField('templateName')) { $entity->setTemplate($template['template']); $entity->setController($template['controller']); $uow->recomputeSingleEntityChangeSet($em->getClassMetadata("NetworkingInitCmsBundle:ContentRoute"), $entity); } } }
/** * @param EventArgs $eventArgs */ public function loadClassMetadata(EventArgs $eventArgs) { /* @var $classMetadata ClassMetadata */ $classMetadata = $eventArgs->getClassMetadata(); // If the entity is a subclass with STI, it gets its already prefixed table from inherited class if (!$classMetadata->isInheritanceTypeSingleTable() || $classMetadata->getName() === $classMetadata->rootEntityName) { $classMetadata->setTableName($this->prefix . $classMetadata->getTableName()); } foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) { if ($mapping['type'] === ClassMetadataInfo::MANY_TO_MANY && !$classMetadata->isInheritedAssociation($fieldName) && isset($classMetadata->associationMappings[$fieldName]['joinTable']['name'])) { $mappedTableName = $classMetadata->associationMappings[$fieldName]['joinTable']['name']; $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $this->prefix . $mappedTableName; } } }
/** * @dataProvider provideDoctrineEvents */ public function testDoctrineConditionalDeferredIsExecutedIfEventFired($event) { $this->doctrineDeferred->expects($this->once())->method('getEvents')->will($this->returnValue(array('evt1', $event, 'evt2'))); $this->decorator->{$event}(EventArgs::getEmptyInstance()); $this->executor->expects($this->once())->method('execute')->with($this->doctrineDeferred); $this->decorator->execute($this->doctrineDeferred); }
public function preRemove(EventArgs $args) { $chain = $this->container->get('oneup_acl.driver_chain'); $manager = $this->container->get('oneup_acl.manager'); $remove = $this->container->getParameter('oneup_acl.remove_orphans'); if ($args instanceof \Doctrine\ODM\MongoDB\Event\LifecycleEventArgs) { $entity = $args->getDocument(); } else { $entity = $args->getObject(); } $object = new \ReflectionClass($entity); $metaData = $chain->readMetaData($object); if ($remove && (!isset($metaData['remove']) || $metaData['remove']) || !$remove && isset($metaData['remove']) && $metaData['remove']) { $manager->revokeAllObjectPermissions($entity); $manager->revokeAllObjectFieldPermissions($entity); } }
/** * @param EventArgs $eventArgs */ public function loadClassMetadata(EventArgs $eventArgs) { $metadata = $eventArgs->getClassMetadata(); if ($metadata->isMappedSuperclass) { return; } $mappings = $metadata->getAssociationMappings(); $name = $metadata->getName(); if (!isset($mappings['metadata']) && in_array($this->targetEntity, class_implements($name))) { $reflClass = $metadata->getReflectionClass(); $namespace = $reflClass->getNamespaceName(); $classShortName = $reflClass->getShortName(); $metadata->mapOneToMany(['targetEntity' => "{$namespace}\\{$classShortName}Metadata", 'fieldName' => 'metadata', 'mappedBy' => 'object', 'orphanRemoval' => true, 'cascade' => ['persist', 'remove'], 'fetch' => 'EXTRA_LAZY']); } elseif (!isset($mappings['object']) && is_subclass_of($name, $this->sourceEntity)) { $namingStrategy = $eventArgs->getEntityManager()->getConfiguration()->getNamingStrategy(); $metadata->mapManyToOne(['targetEntity' => str_replace('Metadata', '', $name), 'fieldName' => 'object', 'inversedBy' => 'metadata', 'joinColumn' => ['name' => 'object_id', 'referencedColumnName' => $namingStrategy->referenceColumnName(), 'onDelete' => 'CASCADE', 'onUpdate' => 'CASCADE']]); } }
/** * Dispatches an event to all registered listeners. * * @param string $eventName The name of the event to dispatch. The name of the event is * the name of the method that is invoked on listeners. * @param EventArgs $eventArgs The event arguments to pass to the event handlers/listeners. * If not supplied, the single empty EventArgs instance is used. * @return boolean */ public function dispatchEvent($eventName, EventArgs $eventArgs = null) { if (isset($this->_listeners[$eventName])) { $eventArgs = $eventArgs === null ? EventArgs::getEmptyInstance() : $eventArgs; foreach ($this->_listeners[$eventName] as $listener) { $listener->{$eventName}($eventArgs); } } }
/** * Compute sortRank for entities that are created * * @param EventArgs $args */ public function prePersist(EventArgs $args) { $em = $args->getEntityManager(); $object = $args->getObject(); $class = get_class($object); $meta = $em->getClassMetadata($class); $reflectionClass = $meta->getReflectionClass(); if (!$reflectionClass || !$this->hasTrait($reflectionClass, 'Librinfo\\DoctrineBundle\\Entity\\Traits\\Sortable')) { return; } // return if current entity doesn't use Sortable trait if ($object->getSortRank()) { return; } $maxPos = $this->getMaxPosition($em, $meta); $maxPos = $maxPos ? $maxPos + 1000 : 65536; $object->setSortRank($maxPos); $this->maxPositions[$class] = $maxPos; }
/** * @param EventArgs $eventArgs */ public function loadClassMetadata(EventArgs $eventArgs) { $meta = $eventArgs->getClassMetadata(); if ($meta->isInheritanceTypeNone()) { return; } $className = $meta->getName(); if (!empty($this->discriminatorMaps[$className])) { foreach ($this->discriminatorMaps[$className] as $entry => $className) { if (in_array($className, $meta->discriminatorMap)) { $meta->discriminatorMap = array_diff($meta->discriminatorMap, [$className]); } $meta->discriminatorMap[$entry] = $className; if (!in_array($className, $meta->subClasses) && $className !== $meta->name) { $meta->subClasses[] = $className; } } } }
/** * @param EventArgs $args */ private function preUpload(EventArgs $args) { $em = $args->getEntityManager(); $uow = $args->getEntityManager()->getUnitOfWork(); $entities = array(); foreach ($uow->getScheduledEntityInsertions() as $entity) { $entities[] = $entity; } foreach ($uow->getScheduledEntityUpdates() as $entity) { $entities[] = $entity; } foreach ($entities as $entity) { $bigfootFileFields = $this->getBigfootFileFields($entity); foreach ($bigfootFileFields as $bigfootFileField) { $this->fileManager->preUpload($entity, $bigfootFileField['filePathProperty'], $bigfootFileField['fileFieldProperty']); $meta = $em->getClassMetadata(get_class($entity)); $uow->recomputeSingleEntityChangeSet($meta, $entity); } } }
/** * Dispatches an event to all registered listeners. * * @param string $eventName The name of the event to dispatch. The name of the event is * the name of the method that is invoked on listeners. * @param EventArgs|null $eventArgs The event arguments to pass to the event handlers/listeners. * If not supplied, the single empty EventArgs instance is used. * * @return boolean */ public function dispatchEvent($eventName, EventArgs $eventArgs = null) { if (!$this->hasListeners($eventName)) { return; } $eventArgs = $eventArgs === null ? EventArgs::getEmptyInstance() : $eventArgs; foreach ($this->getListeners($eventName) as $listener) { $listener->{$eventName}($eventArgs); if ($eventArgs instanceof RejectInterface && $eventArgs->getReject()) { break; } } }
/** * Dispatches an event to all registered listeners. * * @param string $eventName The name of the event to dispatch. The name of the event is * the name of the method that is invoked on listeners. * @param EventArgs $eventArgs The event arguments to pass to the event handlers/listeners. * If not supplied, the single empty EventArgs instance is used. * * @return bool */ public function dispatchEvent($eventName, EventArgs $eventArgs = null) { if (isset($this->listeners[$eventName])) { $eventArgs = null === $eventArgs ? EventArgs::getEmptyInstance() : $eventArgs; $initialized = isset($this->initialized[$eventName]); foreach ($this->listeners[$eventName] as $hash => $listener) { if (!$initialized && is_string($listener)) { $this->listeners[$eventName][$hash] = $listener = $this->container->get($listener); } $listener->{$eventName}($eventArgs); } $this->initialized[$eventName] = true; } }
/** * {@inheritDoc} */ public function getObjectFromArgs(EventArgs $e) { return $e->getEntity(); }
/** * {@inheritdoc} */ protected function getMedia(EventArgs $args) { return $args->getDocument(); }
/** * @inheritdoc */ protected function getMedia(EventArgs $args) { return $args->getEntity(); }
/** * Create a new activity * * @param EventArgs $eventArgs * @param string $verb * @param object $entity * * @return ActivityStream */ public function createActivity(EventArgs $eventArgs, $verb, $entity) { $em = $eventArgs->getEntityManager(); $entityClass = \Doctrine\Common\Util\ClassUtils::getClass($entity); $classMetaData = $em->getClassMetadata($entityClass); if (!$classMetaData->reflClass->implementsInterface('Jumph\\Bundle\\DashboardBundle\\Entity\\ActivityInterface')) { return ''; } $activityStreamMeta = $em->getClassMetadata("JumphDashboardBundle:ActivityStream"); $uow = $em->getUnitOfWork(); $activityStream = new ActivityStream(); $activityStream->setVerb($verb); $activityStream->setObjectType($entityClass); $activityStream->setUser($this->user); if ($verb === 'create') { $this->pendingInserts[spl_object_hash($entity)] = $activityStream; } else { $activityStream->setObjectId($entity->getId()); } $em->persist($activityStream); $uow->computeChangeSet($activityStreamMeta, $activityStream); return $activityStream; }
public function postLoad(EventArgs $event) { $entity = $event->getEntity(); $this->initializer->initialize($entity, $this->serviceLocator); }
/** * {@inheritDoc} */ public function getLoadedMetaDatas(EventArgs $e) { return $e->getEntityManager()->getMetadataFactory()->getLoadedMetadata(); }
/** * Sets the specific sortOrders. * * @param EventArgs $eventArgs * * @access private * @return array * @author Etienne de Longeaux <*****@*****.**> */ private function getSortableOrders($eventArgs) { $entity = $eventArgs->getEntity(); $entityManager = $eventArgs->getEntityManager(); $entity_name = get_class($entity); $metadata = $entityManager->getClassMetadata($entity_name); $reflectionClass = new ReflectionClass($entity); $properties = $reflectionClass->getProperties(); // initialize sort values; $results['sort_position_by_and'] = " "; $results['sort_position_by_where'] = " "; // foreach ($properties as $refProperty) { if ($this->annReader->getPropertyAnnotation($refProperty, $this->annotationclass)) { // we have annotation and if it decrypt operation, we must avoid duble decryption $propName = $refProperty->getName(); $methodName = \Sfynx\ToolBundle\Util\PiStringManager::capitalize($propName); if ($reflectionClass->hasMethod($getter = 'get' . $methodName) && $reflectionClass->hasMethod($setter = 'set' . $methodName)) { $properties = $this->annReader->getPropertyAnnotation($refProperty, $this->annotationclass); if (is_array($properties->SortableOrders) && isset($properties->SortableOrders['field']) && isset($properties->SortableOrders['type'])) { $field = $properties->SortableOrders['field']; $columnName = $properties->SortableOrders['columnName']; $methode = 'get' . \Sfynx\ToolBundle\Util\PiStringManager::capitalize($field); $type = $properties->SortableOrders['type']; if (method_exists($entity, $methode) && $type == 'relationship' && !is_null($entity->{$methode}())) { $results['sort_position_by_and'] = " AND (mytable.{$columnName} = '{$entity->{$methode}()->getId()}')"; $results['sort_position_by_where'] = " WHERE (mytable.{$columnName} = '{$entity->{$methode}()->getId()}')"; } elseif (method_exists($entity, $methode)) { $results['sort_position_by_and'] = " AND (mytable.{$columnName} = '{$entity->{$methode}()}')"; $results['sort_position_by_where'] = " WHERE (mytable.{$columnName} = '{$entity->{$methode}()}')"; } } } } } // Exemple : // @PI\Positioned(SortableOrders = {"type":"relationship","field":"page","columnName":"page_id"}) // is like this : // if (($entity instanceof \MyEnity && method_exists($entity, 'getObject')){ // $obj = $entity->getObject(); // if ($obj instanceof \MyObject){ // $results['sort_position_by_and'] = " AND (mytable.page_id = '{$obj->getId()}')"; // $results['sort_position_by_where'] = " WHERE (mytable.page_id = '{$obj->getId()}')"; // } // } return $results; }
/** * @return object Manager */ public function getEntityManager() { return $this->eventArgs->getEntityManager(); }
public function postFlush(EventArgs $args) { if ($this->post_flush_persist_counter) { $om = $args->getEntityManager(); $om->flush(); } }
/** * @param \Doctrine\Common\EventArgs $args * @return void */ protected function recomputeSingleEntityChangeSet(EventArgs $args) { $em = $args->getEntityManager(); $em->getUnitOfWork()->recomputeSingleEntityChangeSet($em->getClassMetadata(get_class($args->getEntity())), $args->getEntity()); }