/**
* @param string $className
* @param string $association
* @param array $ownerIdentifier
* @param array $data
*/
private function putCollectionCacheEntry($className, $association, array $ownerIdentifier, array $data)
{
$metadata = $this->em->getClassMetadata($className);
$cacheKey = new CollectionCacheKey($metadata->name, $association, $ownerIdentifier);
$cacheEntry = new CollectionCacheEntry($data);
$persister = $this->em->getUnitOfWork()->getCollectionPersister($metadata->getAssociationMapping($association));
$persister->getCacheRegion()->put($cacheKey, $cacheEntry);
}
/**
* @param Game $game
* @return bool
*/
protected function hasGameAlreadyStarted(Game $game)
{
$unitOfWork = $this->entityManager->getUnitOfWork();
$changes = $unitOfWork->getEntityChangeSet($game);
$changeFieldKey = sprintf('user%dShips', $game->getPlayerNumber());
// old ships if changed, or current ships
$playerShipsBeforeChanges = isset($changes[$changeFieldKey]) ? $changes[$changeFieldKey][0] : $game->getPlayerShips();
// game started if ships already set
return count($playerShipsBeforeChanges) > 0;
}
public function testCreateOriginalEntityIdentity()
{
$gallery = new Gallery('Riverstreet 12');
$gallery->addVisitor('Foo de Bar');
$this->em->persist($gallery);
$this->em->flush();
$gallery->addVisitor('Bar Baz');
$this->em->getUnitOfWork()->computeChangeSets();
$this->em->flush();
$original = $this->provider->createOriginalEntity($this->em, $gallery);
self::assertSame($gallery->getId(), $original->getId());
}
/**
* Set updated at to current DateTime when related entities updated
* TODO: consider refactoring of this feature to make it applicable to all entities
*
* @param Contact $entity
*/
protected function setUpdatedAt(Contact $entity)
{
/** @var UnitOfWork $uow */
$uow = $this->manager->getUnitOfWork();
$uow->computeChangeSets();
$isEntityChanged = count($uow->getEntityChangeSet($entity)) > 0;
$isRelationChanged = count($uow->getScheduledEntityUpdates()) > 0 || count($uow->getScheduledCollectionUpdates()) > 0 || count($uow->getScheduledCollectionDeletions()) > 0;
if (false === $isEntityChanged && $isRelationChanged) {
$entity->setUpdatedAt(new \DateTime('now', new \DateTimeZone('UTC')));
$this->manager->persist($entity);
}
}
private function prepare($data)
{
$metaDataClass = $this->entityManager->getClassMetadata(get_class($data));
$assocFields = $metaDataClass->getAssociationMappings();
foreach ($assocFields as $assoc) {
$relatedEntities = $metaDataClass->reflFields[$assoc['fieldName']]->getValue($data);
if ($relatedEntities instanceof Collection) {
if ($relatedEntities === $metaDataClass->reflFields[$assoc['fieldName']]->getValue($data)) {
continue;
}
if ($relatedEntities instanceof PersistentCollection) {
// Unwrap so that foreach() does not initialize
$relatedEntities = $relatedEntities->unwrap();
}
foreach ($relatedEntities as $relatedEntity) {
$relatedEntitiesState = $this->entityManager->getUnitOfWork()->getEntityState($relatedEntities);
if ($relatedEntitiesState === UnitOfWork::STATE_DETACHED) {
$metaDataClass->setFieldValue($data, $assoc['fieldName'], $this->entityManager->merge($relatedEntity));
}
}
} else {
if ($relatedEntities !== null) {
$relatedEntitiesState = $this->entityManager->getUnitOfWork()->getEntityState($relatedEntities);
if ($relatedEntitiesState === UnitOfWork::STATE_DETACHED) {
$metaDataClass->setFieldValue($data, $assoc['fieldName'], $this->entityManager->merge($relatedEntities));
}
}
}
}
}
/**
* Processes an individual parameter value.
*
* @param mixed $value
*
* @return array|string
*
* @throws \Doctrine\ORM\ORMInvalidArgumentException
*/
public function processParameterValue($value)
{
if (is_scalar($value)) {
return $value;
}
if ($value instanceof Collection) {
$value = $value->toArray();
}
if (is_array($value)) {
foreach ($value as $key => $paramValue) {
$paramValue = $this->processParameterValue($paramValue);
$value[$key] = is_array($paramValue) ? reset($paramValue) : $paramValue;
}
return $value;
}
if (is_object($value) && $this->_em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
$value = $this->_em->getUnitOfWork()->getSingleIdentifierValue($value);
if ($value === null) {
throw ORMInvalidArgumentException::invalidIdentifierBindingEntity();
}
}
if ($value instanceof Mapping\ClassMetadata) {
return $value->name;
}
return $value;
}
/**
* Initializes a new instance of a class derived from AbstractCollectionPersister.
*
* @param EntityManagerInterface $em
*/
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
$this->uow = $em->getUnitOfWork();
$this->conn = $em->getConnection();
$this->platform = $this->conn->getDatabasePlatform();
$this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
}
/**
* Occur on nestednode.page.preupdate events and nestednode.section.preupdate.
*
* @access public
*
* @param Event $event
*/
public function onFlushPage(Event $event)
{
$uow = $this->entityManager->getUnitOfWork();
$page = $event->getTarget();
if ($uow->isScheduledForInsert($page) && $page->getParent() !== null && $page->getState() < 4) {
self::setSectionHasChildren($page->getParent()->getSection(), +1);
}
}
/**
* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
* @param \Doctrine\ORM\Cache\Region $region The query region.
*/
public function __construct(EntityManagerInterface $em, Region $region)
{
$cacheConfig = $em->getConfiguration()->getSecondLevelCacheConfiguration();
$this->em = $em;
$this->region = $region;
$this->uow = $em->getUnitOfWork();
$this->cacheLogger = $cacheConfig->getCacheLogger();
$this->validator = $cacheConfig->getQueryValidator();
}
/**
* Initializes a new instance of the <tt>ProxyFactory</tt> class that is
* connected to the given <tt>EntityManager</tt>.
*
* @param EntityManagerInterface $em The EntityManager the new factory works for.
* @param string $proxyDir The directory to use for the proxy classes. It must exist.
* @param string $proxyNs The namespace to use for the proxy classes.
* @param boolean|int $autoGenerate The strategy for automatically generating proxy classes. Possible
* values are constants of Doctrine\Common\Proxy\AbstractProxyFactory.
*/
public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = AbstractProxyFactory::AUTOGENERATE_NEVER)
{
$proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
$proxyGenerator->setPlaceholder('baseProxyInterface', 'Doctrine\\ORM\\Proxy\\Proxy');
parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
$this->em = $em;
$this->uow = $em->getUnitOfWork();
$this->proxyNs = $proxyNs;
$this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
}
/**
* Register entity as managed in UnitOfWork.
*
* @param ClassMetadata $class
* @param object $entity
* @param array $data
*
* @return void
*
* @todo The "$id" generation is the same of UnitOfWork#createEntity. Remove this duplication somehow
*/
protected function registerManaged(ClassMetadata $class, $entity, array $data)
{
if ($class->isIdentifierComposite) {
$id = array();
foreach ($class->identifier as $fieldName) {
$id[$fieldName] = isset($class->associationMappings[$fieldName]) ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']] : $data[$fieldName];
}
} else {
$fieldName = $class->identifier[0];
$id = array($fieldName => isset($class->associationMappings[$fieldName]) ? $data[$class->associationMappings[$fieldName]['joinColumns'][0]['name']] : $data[$fieldName]);
}
$this->_em->getUnitOfWork()->registerManaged($entity, $id, $data);
}
/**
* Dumps the contents of the identity map into a stream.
*
* @param EntityManagerInterface $em
*
* @return void
*/
public function dumpIdentityMap(EntityManagerInterface $em)
{
$uow = $em->getUnitOfWork();
$identityMap = $uow->getIdentityMap();
$fh = fopen($this->file, "x+");
if (count($identityMap) == 0) {
fwrite($fh, "Flush Operation [" . $this->context . "] - Empty identity map.\n");
return;
}
fwrite($fh, "Flush Operation [" . $this->context . "] - Dumping identity map:\n");
foreach ($identityMap as $className => $map) {
fwrite($fh, "Class: " . $className . "\n");
foreach ($map as $entity) {
fwrite($fh, " Entity: " . $this->getIdString($entity, $uow) . " " . spl_object_hash($entity) . "\n");
fwrite($fh, " Associations:\n");
$cm = $em->getClassMetadata($className);
foreach ($cm->associationMappings as $field => $assoc) {
fwrite($fh, " " . $field . " ");
$value = $cm->getFieldValue($entity, $field);
if ($assoc['type'] & ClassMetadata::TO_ONE) {
if ($value === null) {
fwrite($fh, " NULL\n");
} else {
if ($value instanceof Proxy && !$value->__isInitialized()) {
fwrite($fh, "[PROXY] ");
}
fwrite($fh, $this->getIdString($value, $uow) . " " . spl_object_hash($value) . "\n");
}
} else {
$initialized = !$value instanceof PersistentCollection || $value->isInitialized();
if ($value === null) {
fwrite($fh, " NULL\n");
} elseif ($initialized) {
fwrite($fh, "[INITIALIZED] " . $this->getType($value) . " " . count($value) . " elements\n");
foreach ($value as $obj) {
fwrite($fh, " " . $this->getIdString($obj, $uow) . " " . spl_object_hash($obj) . "\n");
}
} else {
fwrite($fh, "[PROXY] " . $this->getType($value) . " unknown element size\n");
foreach ($value->unwrap() as $obj) {
fwrite($fh, " " . $this->getIdString($obj, $uow) . " " . spl_object_hash($obj) . "\n");
}
}
}
}
}
}
fclose($fh);
}
/**
* Update all properties to ical requirements and apply changes to dependent attributes:
* - set $dtStart and $dtEnd according to the selected values from $dateFrom, $timeFrom, $dateTo and $timeTo
* - remove $recurrenceRule if it's $frequency is empty
* - set $recurrenceRule's $byDay value to null if empty
* - apply changed $dtStart values to $excludedDates
* Must be executed on persisting the event. Should be called prior to any validation.
*
* @param Event $event
*/
public function cleanUpEvent(Event $event)
{
if ($event->getDateFrom()) {
//merge dates and times, apply noTime setting
$event->setDtStart($event->getDateFrom());
if (is_null($event->getTimeFrom())) {
$event->getDtStart()->setTime(0, 0);
$event->setTimeFrom(new \DateTime('1970-01-01'));
} else {
$event->getDtStart()->setTime($event->getTimeFrom()->format('H'), $event->getTimeFrom()->format('i'));
}
}
if ($event->getDateTo()) {
$event->setDtEnd(clone $event->getDateTo());
if (is_null($event->getTimeTo())) {
$event->getDtEnd()->setTime(0, 0);
$event->setTimeTo(new \DateTime('1970-01-01'));
} else {
$event->getDtEnd()->setTime($event->getTimeTo()->format('H'), $event->getTimeTo()->format('i'));
}
if ($event->isNoTime()) {
$event->getDtEnd()->add(new \DateInterval('P1D'));
}
}
//do the following only if event is recurring
if ($event->getRecurrenceRule()) {
//remove recurring rule if empty and nullify "byDay" property if empty
if ('' == $event->getRecurrenceRule()->getFreq()) {
$this->em->remove($event->getRecurrenceRule());
$event->removeRecurrenceRule();
} elseif ('' == $event->getRecurrenceRule()->getByDay()) {
$event->getRecurrenceRule()->setByDay(null);
}
//update excludeDates
/** @var $entity \Xima\ICalBundle\Entity\Component\Event */
$uow = $this->em->getUnitOfWork();
$changeSet = $uow->getEntityChangeSet($event);
if (isset($changeSet['dtStart']) && isset($changeSet['dtStart'][0])) {
$interval = $changeSet['dtStart'][0]->diff($event->getDtStart());
foreach ($event->getExDates() as $dateTime) {
$dateTime->add($interval);
}
}
}
}
/**
* {@inheritdoc}
*/
protected function doInitialize()
{
// Has NEW objects added through add(). Remember them.
$newObjects = array();
if ($this->isDirty) {
$newObjects = $this->collection->toArray();
}
$this->collection->clear();
$this->em->getUnitOfWork()->loadCollection($this);
$this->takeSnapshot();
// Reattach NEW objects added through add(), if any.
if ($newObjects) {
foreach ($newObjects as $obj) {
$this->collection->add($obj);
}
$this->isDirty = true;
}
}
/**
* Selects all elements from a selectable that match the expression and
* return a new collection containing these elements.
*
* @param \Doctrine\Common\Collections\Criteria $criteria
*
* @return Collection
*
* @throws \RuntimeException
*/
public function matching(Criteria $criteria)
{
if ($this->isDirty) {
$this->initialize();
}
if ($this->initialized) {
return $this->collection->matching($criteria);
}
if ($this->association['type'] === ClassMetadata::MANY_TO_MANY) {
$persister = $this->em->getUnitOfWork()->getCollectionPersister($this->association);
return new ArrayCollection($persister->loadCriteria($this, $criteria));
}
$builder = Criteria::expr();
$ownerExpression = $builder->eq($this->backRefFieldName, $this->owner);
$expression = $criteria->getWhereExpression();
$expression = $expression ? $builder->andX($expression, $ownerExpression) : $ownerExpression;
$criteria = clone $criteria;
$criteria->where($expression);
$persister = $this->em->getUnitOfWork()->getEntityPersister($this->association['targetEntity']);
return $this->association['fetch'] === ClassMetadataInfo::FETCH_EXTRA_LAZY ? new LazyCriteriaCollection($persister, $criteria) : new ArrayCollection($persister->loadCriteria($criteria));
}
/**
* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
*/
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
$this->uow = $em->getUnitOfWork();
}
/**
* @param \Doctrine\ORM\Persisters\Collection\CollectionPersister $persister The collection persister that will be cached.
* @param \Doctrine\ORM\Cache\Region $region The collection region.
* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
* @param array $association The association mapping.
*/
public function __construct(CollectionPersister $persister, Region $region, EntityManagerInterface $em, array $association)
{
$configuration = $em->getConfiguration();
$cacheConfig = $configuration->getSecondLevelCacheConfiguration();
$cacheFactory = $cacheConfig->getCacheFactory();
$this->region = $region;
$this->persister = $persister;
$this->association = $association;
$this->regionName = $region->getName();
$this->uow = $em->getUnitOfWork();
$this->metadataFactory = $em->getMetadataFactory();
$this->cacheLogger = $cacheConfig->getCacheLogger();
$this->hydrator = $cacheFactory->buildCollectionHydrator($em, $association);
$this->sourceEntity = $em->getClassMetadata($association['sourceEntity']);
$this->targetEntity = $em->getClassMetadata($association['targetEntity']);
}
/**
* {@inheritdoc}
*/
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
$this->uow = $em->getUnitOfWork();
$this->cacheFactory = $em->getConfiguration()->getSecondLevelCacheConfiguration()->getCacheFactory();
}
protected function getEntityPersister($entity)
{
$uow = $this->em->getUnitOfWork();
return $uow->getEntityPersister($entity);
}
/**
* @param EntityManagerInterface $em
* @param mixed $entity
* @return bool
*/
public function isEntityManaged(EntityManagerInterface $em, $entity)
{
return $em->getUnitOfWork()->getEntityState($entity) === UnitOfWork::STATE_MANAGED;
}
/**
* {@inheritdoc}
*/
public function getUnitOfWork()
{
return $this->wrapped->getUnitOfWork();
}
/**
* @param object $entity
*/
protected function updateChangeSets($entity)
{
$metadata = $this->getMetadataForEntity($entity);
$this->entityManager->getUnitOfWork()->recomputeSingleEntityChangeSet($metadata, $entity);
}
/**
* Builds criteria and execute SQL statement to fetch the one to many entities from.
*
* @param array $assoc
* @param object $sourceEntity
* @param int|null $offset
* @param int|null $limit
*
* @return \Doctrine\DBAL\Statement
*/
private function getOneToManyStatement(array $assoc, $sourceEntity, $offset = null, $limit = null)
{
$this->switchPersisterContext($offset, $limit);
$criteria = array();
$parameters = array();
$owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
$sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
$tableAlias = $this->getSQLTableAlias(isset($owningAssoc['inherited']) ? $owningAssoc['inherited'] : $this->class->name);
foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
if ($sourceClass->containsForeignIdentifier) {
$field = $sourceClass->getFieldForColumn($sourceKeyColumn);
$value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
if (isset($sourceClass->associationMappings[$field])) {
$value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
$value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
}
$criteria[$tableAlias . "." . $targetKeyColumn] = $value;
$parameters[] = array('value' => $value, 'field' => $field, 'class' => $sourceClass);
continue;
}
$field = $sourceClass->fieldNames[$sourceKeyColumn];
$value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
$criteria[$tableAlias . "." . $targetKeyColumn] = $value;
$parameters[] = array('value' => $value, 'field' => $field, 'class' => $sourceClass);
}
$sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
list($params, $types) = $this->expandToManyParameters($parameters);
return $this->conn->executeQuery($sql, $params, $types);
}
/**
* @param EntityManagerInterface $em
* @return array
*/
public function getFullChangeSet(EntityManagerInterface $em)
{
return $em->getUnitOfWork()->getIdentityMap();
}
/**
* Retrieves an individual parameter value.
*
* @param mixed $value
*
* @return mixed
*/
private function getIndividualValue($value)
{
if (!is_object($value) || !$this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
return $value;
}
return $this->em->getUnitOfWork()->getSingleIdentifierValue($value);
}
/**
* @param \Doctrine\ORM\Persisters\Entity\EntityPersister $persister The entity persister to cache.
* @param \Doctrine\ORM\Cache\Region $region The entity cache region.
* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
* @param \Doctrine\ORM\Mapping\ClassMetadata $class The entity metadata.
*/
public function __construct(EntityPersister $persister, Region $region, EntityManagerInterface $em, ClassMetadata $class)
{
$configuration = $em->getConfiguration();
$cacheConfig = $configuration->getSecondLevelCacheConfiguration();
$cacheFactory = $cacheConfig->getCacheFactory();
$this->class = $class;
$this->region = $region;
$this->persister = $persister;
$this->cache = $em->getCache();
$this->regionName = $region->getName();
$this->uow = $em->getUnitOfWork();
$this->metadataFactory = $em->getMetadataFactory();
$this->cacheLogger = $cacheConfig->getCacheLogger();
$this->timestampRegion = $cacheFactory->getTimestampRegion();
$this->hydrator = $cacheFactory->buildEntityHydrator($em, $class);
$this->timestampKey = new TimestampCacheKey($this->class->getTableName());
}
/**
* @param \Doctrine\ORM\EntityManagerInterface $em The entity manager.
*/
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
$this->uow = $em->getUnitOfWork();
$this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
}
/**
* Constructor
*
* @param EntityManagerInterface $entityManager
*/
public function __construct(EntityManagerInterface $entityManager)
{
$this->entityManager = $entityManager;
$this->unitOfWork = $entityManager->getUnitOfWork();
}
/**
* {@inheritdoc}
*/
public function buildCollectionHydrator(EntityManagerInterface $em, array $mapping)
{
/* @var $targetPersister \Doctrine\ORM\Cache\Persister\CachedPersister */
$targetPersister = $em->getUnitOfWork()->getEntityPersister($mapping['targetEntity']);
return new DefaultCollectionHydrator($em, $targetPersister->getCacheRegion());
}
