/**
* postPersist
*
* @param LifecycleEventArgs $event
*/
public function postPersist(LifecycleEventArgs $event)
{
//When the parent is created, the resource is load
if ($event->getObject() == $this->context) {
if ($this->accessor->isReadable($this->context, $this->property) && ($resource = $this->accessor->getValue($this->context, $this->property))) {
if ($resource instanceof ResourceObjectInterface) {
$resource = $this->loader->load($this->context, $this->property, $this->file);
//to avoid bubbling with the preUpdate
//$this->context = null;
$event->getEntityManager()->flush($resource);
}
}
} else {
$meta = $event->getEntityManager()->getClassMetadata(get_class($this->context));
$identifier = $meta->getSingleIdentifierColumnName();
//when the parent exists but the resource is created
if ($meta->getFieldValue($this->context, $identifier)) {
if ($this->accessor->isReadable($this->context, $this->property) && $event->getObject() == $this->accessor->getValue($this->context, $this->property)) {
if (($resource = $event->getObject()) && $resource instanceof ResourceObjectInterface) {
$this->loader->load($this->context, $this->property, $this->file);
//to avoid bubbling with the preUpdate
//$this->context = null;
$event->getEntityManager()->flush($resource);
}
}
}
}
}
public function prePersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$classHierarchyMetadata = $this->metadataFactory->getMetadataForClass(get_class($entity));
$classMetadata = $classHierarchyMetadata->classMetadata[get_class($entity)];
foreach ($classMetadata->propertyMetadata as $propertyMetadata) {
switch ($propertyMetadata->type) {
case 'odm':
$dm = $this->doctrine->getManager($propertyMetadata->targetManager);
// Copied following two lines from Doctrine\ORM\Mapping\ClassMetadataFactory
list($namespaceAlias, $simpleClassName) = explode(':', $propertyMetadata->targetObject);
$realClassName = $dm->getConfiguration()->getDocumentNamespace($namespaceAlias) . '\\' . $simpleClassName;
/**
* @var \Doctrine\Common\Persistence\Mapping\ClassMetadata $documentMetaData
*/
$documentMetaData = $dm->getClassMetadata($realClassName);
$document = $propertyMetadata->getValue($entity);
if (is_null($document)) {
continue;
}
$idValues = $documentMetaData->getIdentifierValues($document);
$propertyMetadata->setValue($entity, serialize($idValues));
$class = $args->getEntityManager()->getClassMetadata(get_class($entity));
$args->getEntityManager()->getUnitOfWork()->recomputeSingleEntityChangeSet($class, $entity);
break;
case 'mongodb':
throw new \Exception('MongoDB is not yet implemented');
break;
default:
break;
}
}
}
public function postPersist(LifecycleEventArgs $args)
{
$obj = $args->getEntity();
// On veut envoyer un email que pour les entités Application
if ($obj instanceof Article) {
$article = $obj;
$em = $args->getEntityManager();
$news = new News();
$news->setType("article");
$news->setArticle($article);
$news->createAbstract($article->getContent());
$em->persist($news);
$em->flush();
//On flush pour créer l'id du content
}
if ($obj instanceof Playlist) {
$playlist = $obj;
$em = $args->getEntityManager();
$news = new News();
$news->setType("playlist");
$news->setPlaylist($playlist);
$news->createAbstract("");
$em->persist($news);
$em->flush();
//On flush pour créer l'id du content
}
return;
}
/**
* @param LifecycleEventArgs $args
*/
public function prePersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if (!$this->isContactEntity($entity)) {
return;
}
/** @var Contact $entity */
$this->setCreatedProperties($entity, $args->getEntityManager());
$this->setUpdatedProperties($entity, $args->getEntityManager());
}
public function prePersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if ($entity instanceof Vacancy) {
$encoder = new UrlEncoder($args->getEntityManager());
$entity->setUrlId($encoder->encode($entity, $entity->getTitle()));
} else {
if ($entity instanceof Organisation) {
$encoder = new UrlEncoder($args->getEntityManager());
$entity->setUrlId($encoder->encode($entity, $entity->getName()));
}
}
}
/**
* @param LifecycleEventArgs $args
*/
public function prePersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if (!$this->isActivityListEntity($entity)) {
return;
}
/** @var ActivityList $entity */
if (!$entity->getCreatedAt()) {
$this->setCreatedProperties($entity, $args->getEntityManager());
}
if (!$entity->getUpdatedAt()) {
$this->setUpdatedProperties($entity, $args->getEntityManager());
}
}
/**
* @param LifecycleEventArgs $event
*/
public function postPersist(LifecycleEventArgs $event)
{
if (!$this->enabled) {
return;
}
$this->loggableManager->handlePostPersist($event->getEntity(), $event->getEntityManager());
}
public function preRemove(LifecycleEventArgs $eventArgs)
{
$entity = $eventArgs->getEntity();
if ($entity instanceof $this->objectClass) {
$this->scheduleForRemoval($entity, $eventArgs->getEntityManager());
}
}
/**
* Este escucha permite esteblecer el consecutivo de las entidades
* al momento de ser almacenadas en base de datos
* @author Cesar Giraldo <*****@*****.**> 23/12/2015
* @param LifecycleEventArgs $args
*/
public function postPersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$className = get_class($entity);
$entityManager = $args->getEntityManager();
$reflectedClass = new \ReflectionClass($className);
if ($reflectedClass->hasProperty('consecutive')) {
$consecutive = null;
$enabledEntity = false;
if ($entity instanceof Entity\Item) {
$enabledEntity = true;
//buscamos la cantidad de items que tiene creado un proyecto para asignar el consecutivo
$project = $entity->getProject();
$consecutive = $project->getLastItemConsecutive() + 1;
$project->setLastItemConsecutive($consecutive);
$entityManager->persist($project);
} elseif ($entity instanceof Entity\Sprint) {
$enabledEntity = true;
//buscamos la cantidad de items que tiene creado un proyecto para asignar el consecutivo
$project = $entity->getProject();
$consecutive = $project->getLastSprintConsecutive() + 1;
$project->setLastSprintConsecutive($consecutive);
$entityManager->persist($project);
}
if ($enabledEntity) {
if ($consecutive != null) {
$entity->setConsecutive($consecutive);
} else {
$entity->setConsecutive(1);
}
$entityManager->flush();
}
}
}
public function postPersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$entityManager = $args->getEntityManager();
if ($entity instanceof Attachment) {
//var_dump($entity); exit();
if (null === $entity->getFile()) {
return;
}
$id = sprintf('%010d', $entity->getId());
$path = $entity->getStoragePath() . substr($id, 6, 4) . '/' . substr($id, 2, 4) . '/' . $id;
$filename = $entity->getId() . '.' . $entity->getFile()->guessExtension();
if (!file_exists($path)) {
mkdir($path, 0777, true);
}
$entity->setFullpath($path . '/' . $filename);
$entity->getFile()->move($path, $filename);
$entity->setFile(null);
/*
$changelog = new Changelog();
$changelog->setTable($entityManager->getClassMetadata('ProductsBundle:Product')->getTableName());
$changelog->setAction('U');
$changelog->setRecordId($entity->getId());
$changelog->setUser($this->userCallable->getCurrentUser()->getId());
$changelog->setRecordData($entity->jsonSerialize());
*/
$entityManager->flush();
}
}
/**
* @param LifecycleEventArgs $args
*/
public function preUpdate(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if ($entity instanceof NodeTranslation) {
$this->setSlugWhenEmpty($entity, $args->getEntityManager());
}
}
/**
* @param LifecycleEventArgs $args
* @return bool
* @throws \Exception
*/
public function checkBadWords(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if (!$entity instanceof BadWordDetectorInterface) {
return true;
}
$badWords = $args->getEntityManager()->getRepository('RenowazeBundle:BadWord')->findAll();
/** @var BadWordDetector $annotationParams */
$annotationParams = $this->reader->getClassAnnotation(new \ReflectionClass($entity), 'RenowazeBundle\\Annotation\\BadWordDetector');
foreach ($annotationParams->fields as $field) {
$methodName = 'get' . ucfirst($field);
if (!method_exists($entity, $methodName)) {
throw new \Exception(sprintf('Field "%s" not found in entity "%s"', $methodName, get_class($entity)));
}
/** @var BadWord $badWord */
foreach ($badWords as $badWord) {
if (strpos($entity->{$methodName}(), $badWord->getWord()) !== false) {
$entity->setHasBadWords(true);
return true;
}
}
}
$entity->setHasBadWords(false);
return true;
}
/**
* @param LifecycleEventArgs $event
*/
protected function process(LifecycleEventArgs $event)
{
/** @var Page $page */
$page = $event->getEntity();
if (!$this->isApplicable($page)) {
return;
}
$expectedRoute = 'orob2b_cms_page_view';
$expectedParameters = ['id' => $page->getId()];
foreach ($page->getSlugs() as $slug) {
$actualRoute = $slug->getRouteName();
$actualParameters = $slug->getRouteParameters();
$changeSet = [];
if ($actualRoute !== $expectedRoute) {
$slug->setRouteName($expectedRoute);
$changeSet['routeName'] = [$actualRoute, $expectedRoute];
}
if ($actualParameters !== $expectedParameters) {
$slug->setRouteParameters($expectedParameters);
$changeSet['routeParameters'] = [$actualParameters, $expectedParameters];
}
if ($changeSet) {
$unitOfWork = $event->getEntityManager()->getUnitOfWork();
$unitOfWork->scheduleExtraUpdate($slug, $changeSet);
}
}
}
protected function checkRelations(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$entityManager = $args->getEntityManager();
$entityName = (new \ReflectionClass($entity))->getShortName();
if (in_array($entityManager->getClassMetadata(get_class($entity))->name, $this->excludedEntities)) {
return;
}
$mappings = $entityManager->getClassMetadata(get_class($entity))->getAssociationMappings();
foreach ($mappings as $mapping) {
if ($mapping['type'] === ClassMetadataInfo::ONE_TO_MANY || $mapping['type'] === ClassMetadataInfo::MANY_TO_MANY) {
$targetEntityMeta = $entityManager->getClassMetadata($mapping['targetEntity']);
if ($targetEntityMeta->reflClass->getParentClass()) {
if (in_array($targetEntityMeta->reflClass->getParentClass()->name, $this->ignoredEntities)) {
continue;
}
}
$accessor = PropertyAccess::createPropertyAccessor();
$value = $accessor->getValue($entity, $mapping['fieldName']);
if (count($value) === 0) {
continue;
}
$exception = new HasRelationException();
$exception->setEntityName($entityName);
$exception->setEntity($entity);
$exception->setMapping($mapping);
throw $exception;
}
}
}
/**
* Pre remove event handler
*
* @param LifecycleEventArgs $args
*/
public function preRemove(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$classMetadata = $args->getEntityManager()->getClassMetadata(get_class($entity));
$identifiers = $classMetadata->getIdentifierValues($entity);
$this->inventory->setIdentifiers($entity, $identifiers);
}
/**
* Before persist updates WorkflowItem with WorkflowDefinition
*
* @param LifecycleEventArgs $args
*/
public function prePersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if ($entity instanceof WorkflowItem) {
$this->updateWorkflowDefinition($args->getEntityManager(), $entity);
}
}
public function preUpdate(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$entityManager = $args->getEntityManager();
//echo $this->userCallable->getCurrentUser()->getId();
if ($entity instanceof Product) {
/*
$changelog = new Changelog();
$changelog->setTable($entityManager->getClassMetadata('ProductsBundle:Product')->getTableName());
$changelog->setAction('U');
$changelog->setRecordId($entity->getId());
$changelog->setUser($this->userCallable->getCurrentUser()->getId());
$changelog->setRecordData($entity->jsonSerialize());
*/
/*
$item_id = $entity->getItemId();
$item = $entityManager->getRepository('Surgeworks\CoreBundle\Entity\Item')->find($item_id);
$stat_symb = $item->getItemStatus()->getStatusSymbol();
if ($stat_symb != 'st_live') {
$entity->setStatusId($item->getStatusId());
}
*/
//$entityManager->persist($changelog);
//$entityManager->flush();
}
}
/**
* Перед удаление альбома, удаляем все фотограффии, находящиеся в нем,
* и уменьшаем у всех последующих альбомов sortIndex на 10
*
* @param LifecycleEventArgs $args
*/
public function preRemove(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$em = $args->getEntityManager();
if ($entity instanceof \PhotoBundle\Entity\Album) {
$photos = $entity->getPhotos();
foreach ($photos as $photo) {
$em->remove($photo);
}
$sortIndex = $entity->getSortIndex();
$albums = $em->getRepository('PhotoBundle:Album')->getAlbumsWithMoreSortIndex($sortIndex);
foreach ($albums as $album) {
$currentSortIndex = $album->getSortIndex();
$album->setSortIndex($currentSortIndex - 10);
}
} elseif ($entity instanceof Photo) {
$name = $entity->getName();
$pathToImageDirectory = $this->_container->get('request')->server->get('DOCUMENT_ROOT') . '/uploaded/images';
$paths = array($pathToImageDirectory . '/800x800/', $pathToImageDirectory . '/200x200/');
foreach ($paths as $path) {
$fullName = $path . $name;
if (file_exists($fullName)) {
unlink($fullName);
}
}
}
}
/**
* @param \Doctrine\ORM\Event\LifecycleEventArgs $eventArgs
*/
public function postLoad(LifecycleEventArgs $eventArgs)
{
$action = $eventArgs->getEntity();
$className = get_class($action);
$em = $eventArgs->getEntityManager();
$metadata = $em->getClassMetadata($className);
if ($metadata->reflClass->implementsInterface('Redpanda\Bundle\ActivityStreamBundle\Model\ActionInterface')) {
if ($this->streamableResolver->supports($eventArgs, $action->getActorType())) {
$actorReflProp = $metadata->reflClass->getProperty('actor');
$actorReflProp->setAccessible(true);
$actorReflProp->setValue(
$action, $this->streamableResolver->resolve($eventArgs, $action->getActorType(), $action->getActorId())
);
}
if ($this->streamableResolver->supports($eventArgs, $action->getTargetType())) {
$targetReflProp = $metadata->reflClass->getProperty('target');
$targetReflProp->setAccessible(true);
$targetReflProp->setValue(
$action, $this->streamableResolver->resolve($eventArgs, $action->getTargetType(), $action->getTargetId())
);
}
if (null !== $action->getActionObjectType() && $this->streamableResolver->supports($eventArgs, $action->getActionObjectType())) {
$actionObjReflProp = $metadata->reflClass->getProperty('actionObject');
$actionObjReflProp->setAccessible(true);
$actionObjReflProp->setValue(
$action, $this->streamableResolver->resolve($eventArgs, $action->getActionObjectType(), $action->getActionObjectId())
);
}
}
}
/** @ORM\PostLoad */
public function postLoadHandler(RouteEntity $route, LifecycleEventArgs $event)
{
$em = $event->getEntityManager();
$route->setExtendedRouteCallback(function () use($em, $route) {
return $em->getRepository($route->getClass())->findOneBy(array('route' => $route->id));
});
}
public function postPersist(LifecycleEventArgs $event)
{
/** @var OroEntityManager $em */
$em = $event->getEntityManager();
$entity = $event->getEntity();
$configProvider = $em->getExtendManager()->getConfigProvider();
$className = get_class($entity);
if ($configProvider->hasConfig($className)) {
$config = $configProvider->getConfig($className);
$schema = $config->get('schema');
if (isset($schema['relation'])) {
foreach ($schema['relation'] as $fieldName) {
/** @var Config $fieldConfig */
$fieldConfig = $configProvider->getConfig($className, $fieldName);
if ($fieldConfig->getId()->getFieldType() == 'optionSet' && ($setData = $entity->{Inflector::camelize('get_' . $fieldName)}())) {
$model = $configProvider->getConfigManager()->getConfigFieldModel($fieldConfig->getId()->getClassName(), $fieldConfig->getId()->getFieldName());
/**
* in case of single select field type, should wrap value in array
*/
if ($setData && !is_array($setData)) {
$setData = [$setData];
}
foreach ($setData as $option) {
$optionSetRelation = new OptionSetRelation();
$optionSetRelation->setData(null, $entity->getId(), $model, $em->getRepository(OptionSet::ENTITY_NAME)->find($option));
$em->persist($optionSetRelation);
$this->needFlush = true;
}
}
}
}
}
}
/**
* @param LifecycleEventArgs $args
*/
public function postRemove(LifecycleEventArgs $args)
{
$entity = $args->getObject();
$em = $args->getEntityManager();
$meta = $em->getClassMetadata(get_class($entity));
$this->logEntityChange('removed', $meta, $entity);
}
protected function getTranslationMetadataForLifecycleEvent(LifecycleEventArgs $event)
{
$entity = $event->getEntity();
$em = $event->getEntityManager();
$className = get_class($entity);
return $this->getTranslationMetadata($className, $em);
}
/**
* Genera un registro de auditoría con un detalle de los cambios realizados a la entidad.
*
* @param LifecycleEventArgs $eventArgs
*/
public function logChangeSet(LifecycleEventArgs $eventArgs, $action)
{
$em = $eventArgs->getEntityManager();
$uow = $em->getUnitOfWork();
$entity = $eventArgs->getEntity();
$classMetadata = $em->getClassMetadata(get_class($entity));
$user = $this->container->get('security.token_storage')->getToken()->getUser();
if ($this->isEntitySupported($classMetadata->reflClass)) {
$uow->computeChangeSet($classMetadata, $entity);
$changeSet = $uow->getEntityChangeSet($entity);
$this->WriteToLog($action, $entity, $user, $changeSet);
$Registro = new \Tapir\BaseBundle\Entity\AuditoriaRegistro();
$Registro->setAccion($action);
$Registro->setElementoTipo($classMetadata->reflClass->getName());
$Registro->setElementoId($entity->getId());
$Registro->setEstacion($this->container->get('request')->getClientIp());
if (\Tapir\BaseBundle\Helper\ClassHelper::UsaTrait($user, 'Tapir\\BaseBundle\\Entity\\ConIdMetodos')) {
// Algunas veces el usuario no tiene ID (por ejemplo en el entorno de pruebas unitarias)
$Registro->setUsuario($user->getId());
}
//echo '<pre>' . json_encode($changeSet, JSON_PRETTY_PRINT) . '</pre>';
$Registro->setCambios(json_encode($changeSet));
$em->persist($Registro);
$em->flush();
//$em->clear();
//$RegistroMeta = $em->getClassMetadata(get_class($Registro));
//$uow->computeChangeSet($RegistroMeta, $Registro);
}
}
public function postLoad(LifecycleEventArgs $eventArgs)
{
$em = $eventArgs->getEntityManager();
$uow = $em->getUnitOfWork();
$entity = $eventArgs->getEntity();
$classname = get_class($entity);
if (!array_key_exists($classname, $this->getEntities())) {
return null;
}
/** @var Schema $schema */
$schema = $em->getRepository('Padam87AttributeBundle:Schema')->findOneBy(array('className' => $classname));
if ($schema === null) {
throw new \UnexpectedValueException('Schema not found for ' . $classname);
}
$qb = $em->getRepository($classname)->createQueryBuilder('main');
$qb->distinct()->select('d.id')->join('main.attributes', 'a')->join('a.definition', 'd', null, null, 'd.id')->where('main = :main')->setParameter('main', $entity);
$definitions = $qb->getQuery()->getScalarResult();
$ids = array_map('current', $definitions);
foreach ($schema->getDefinitions() as $definition) {
if (!in_array($definition->getId(), $ids)) {
$attribute = new Attribute();
$attribute->setDefinition($definition);
$entity->addAttribute($attribute);
}
}
if ($uow->getEntityState($entity) == UnitOfWork::STATE_MANAGED) {
$em->persist($entity);
$em->flush($entity);
}
}
/** @ORM\PostUpdate */
public function postUpdate(Iban $iban, LifecycleEventArgs $event)
{
$entity = $event->getEntity();
$entityManager = $event->getEntityManager();
$cacheDriver = $entityManager->getConfiguration()->getResultCacheImpl();
$cacheDriver->delete('getIban_' . $iban->getPhotographer()->getId());
}
/**
* @ORM\PostLoad
*
* @param \Venne\Security\User $user
* @param \Doctrine\ORM\Event\LifecycleEventArgs $event
*/
public function postLoadHandler(User $user, LifecycleEventArgs $event)
{
$em = $event->getEntityManager();
$user->setExtendedUserCallback(function () use($em, $user) {
return $em->getRepository($user->getClass())->findOneBy(array('user' => $user->id));
});
}
public function postPersist(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
$entityManager = $args->getEntityManager();
if ($entity instanceof Comment) {
$issue = $entity->getIssue();
$this->setActivity($issue, $entity->getAuthor(), Activity::COMMENT_ISSUE, $entityManager);
}
if ($entity instanceof Issue) {
$currentUser = $this->container->get('security.context')->getToken();
if ($currentUser !== null) {
$user = $currentUser->getUser();
$this->setActivity($entity, $user, Activity::CREATE_ISSUE, $entityManager);
}
}
if ($entity instanceof Activity) {
$collaborators = $entity->getIssue()->getCollaborators();
$emails = [];
foreach ($collaborators as $collaborator) {
$emails[] = $collaborator->getEmail();
}
$message = \Swift_Message::newInstance()->setSubject('Issue activity: ' . $entity->getIssue()->getSummary())->setFrom('*****@*****.**')->setTo($emails)->setBody($this->container->get('templating')->render('AppBundle:Activity:activity.html.twig', ['activities' => $entity]), 'text/html');
$this->container->get('mailer')->send($message);
}
}
public function prePersist(LifecycleEventArgs $event)
{
$object = $event->getObject();
if ($object instanceof UuidAwareInterface and !$object->getId()) {
$object->setId((new UuidGenerator())->generate($event->getEntityManager(), $object));
}
}
public function postRemove(LifecycleEventArgs $args)
{
$entity = $args->getEntity();
if ($entity instanceof TransactionEntity) {
$this->updateBalance($args->getEntityManager());
}
}
