/**
* @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());
}
