I have a Symfony controller action which adds a specified user to the list of followed users (the list is a ManyToMany). The code is quite simple:
public function followUserAction(Request $request, User $followee, $follow)
{
/** #var User */
$user = $this->getUser();
// same user
if ($user === $followee) {
return;
}
$em = $this->getDoctrine()->getManager();
$follow = boolval($follow);
if ($follow && !$user->getFollowedUsers()->contains($followee)) {
$user->addFollowedUser($followee);
} elseif (!$follow && $user->getFollowedUsers()->contains($followee)) {
$user->removeFollowedUser($followee);
}
$em->flush();
}
This is the mapping:
/**
* #var ArrayCollection<int|string, User>
*
* #ORM\ManyToMany(targetEntity="User", fetch="EXTRA_LAZY", inversedBy="followingUsers")
* #ORM\JoinTable(
* joinColumns={#ORM\JoinColumn(name="following_user_id", referencedColumnName="id")},
* inverseJoinColumns={#ORM\JoinColumn(name="followed_user_id", referencedColumnName="id")}
* )
*/
private $followedUsers;
/**
* #var ArrayCollection<int|string, User>
*
* #ORM\ManyToMany(targetEntity="User", fetch="EXTRA_LAZY", mappedBy="followedUsers")
*/
private $followingUsers;
The problem is that when a user clicks many times I am receiving a Duplicate entry. I followed the Doctrine's article about concurrency:
https://www.doctrine-project.org/projects/doctrine-orm/en/2.7/reference/transactions-and-concurrency.html
But unfortunately it doesn't cover the following case:
Check if record exists (SELECT)
If it doesn't exist => insert it
If it already exists => do nothing
If two users make the first SELECT at the same, they will both try to insert the new record.
Any way to solve it?
You can use UniqueConstraintViolationException as proposed at this answer.
Also I think it's good to block UI or throttle user requests at front.
Related
When I try to add new info item it either inserts two of them or none. In the state of code below it inserts two. If i comment something it inserts none. When I comment the line with $em->clear() it inserts exactly one, as I need it. What I don't understand and what I'm doing wrong?
$limit = 10;
$offset = 0;
do {
$products = $selectedModelQuery->getQuery()
->setFirstResult($limit * $offset)
->setMaxResults($limit)->getResult();
$offset++;
$count = count($products);
/** #var \Nti\ApiBundle\Entity\Product $product */
foreach ($selectedModelQuery->getQuery()->getResult() as $product) {
if (!$product->getCollections()->contains($productCollection)) {
$product->addCollection($productCollection);
$productInfo = new ProductInfo;
$productInfo->setProduct($product);
$productInfo->setData($productCollection->getMessage());
$productInfo->setInfoType(ProductInfoInterface::TYPE_CUSTOM);
//$em->merge($product);
//$em->persist($productInfo);
}
}
$em->flush();
$em->clear();
} while ($count);
Main Entity:
class Product {
/**
* #ORM\OneToMany(targetEntity="ProductInfo", mappedBy="product", cascade={"persist", "remove"})
* #var ProductInfoInterface[]|ArrayCollection
*/
protected $infoList;
....
}
Related Entity:
class ProductInfo {
/**
* #ORM\ManyToOne(targetEntity="\Nti\ApiBundle\Entity\Product", inversedBy="infoList")
* #ORM\JoinColumn(name="product_id", referencedColumnName="id", onDelete="CASCADE", nullable=false)
*/
protected $product;
...
}
Doctrine is based on Identity Map that keeps reference to all handled object (ie.: if you try to query two times for the same record by id, first time you hit the db but the second not and object is loaded from Identity Map).
When you use $em->clear() you are "discarding" all objects into Identity Map so, next iteration of do ... while will result in a brand new object (from ORM point of view) that will be flagged for writing operation.
I have a big (simple) problem.
I have a user entity with a geolocation property as an manyToOne relation
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Security\Core\User\AdvancedUserInterface;
/**
* User
*/
class User implements AdvancedUserInterface, \Serializable
{
/**
* #ORM\ManyToOne(targetEntity="AppBundle\Entity\Location", cascade= {"persist"})
* #ORM\JoinColumn(name="location_id", referencedColumnName="id")
*/
private $geolocation;
And I have a location Entity like this:
/**
* Location
*
* #ORM\Table(name="location")
* #ORM\Entity(repositoryClass="AppBundle\Entity\Repository\LocationRepository")
*/
class Location
{
/**
* #var integer
*
* #ORM\Column(name="id", type="integer")
* #ORM\Id
* #ORM\GeneratedValue(strategy="AUTO")
*/
private $id;
/**
* #var string
*
* #Assert\NotBlank()
* #ORM\Column(name="latitude", type="float", scale=12, precision=18)
*/
private $latitude;
/**
* #var string
*
* #Assert\NotBlank()
* #ORM\Column(name="longitude", type="float", scale=12, precision=18)
*/
private $longitude;
/**
* #var string
*
* #Assert\NotBlank()
* #ORM\Column(name="address", type="string", length=255)
*/
private $address;
The Problem is now, that I want to change (update) the location of my users. For that I have a FormType:
$builder->add('geolocation', 'jquerygeolocation', array();
The 'jquerygeolocation' FormType is a created FormType with the
data_class' => 'AppBundle\Entity\Location'
But when I want to change (update) the users location I have a big problem. I want to persist a new location if the location is even not in the database and I want to connect an existing location with the user. But instead doctrine changes only the values of the connected location.
For example:
before:
after:
As you can see, the id is the same. There was only an update. Nothing from the logic I guessed.
Can someone help me with this.
Thanks Michael.
With these relationships you would typically provide a pick list of existing locations and a separate mechanism to create a new location. With a location entity form embedded within your user form any updates will always be applied to the location entity that is already associated with the user.
If you want this to work as described in the question you will need to write some custom code in your controller (or better still in a business logic service used by the controller) to handle it.
Assuming it is the address which uniquely identifies a location then you would need something like this (after handling the request in the controller so that you have a user instance containing the submitted data):
$em = $this->getDoctrine()->getManager();
$locationRepo = $em->getRepository('AppBundle:Location');
$location = $locationRepo->findOneByAddress($user->getGeolocation()->getAddress());
if (!$location)
{
$location = new Location();
$location->setLongitude($user->getGeolocation()->getLongitude());
$location->setLatitude($user->getGeolocation()->getLatitude());
$location->setAddress($user->getGeolocation()->getAddress());
$em->persist($location);
}
$user->setLocation($location);
$em->flush($user);
Very good. This was exactly, what I guessed. But the solution was not as easy like this. In addition to your solution you have to prevent the update on the old location entity. Otherwise the old value is the same as the new location. To do this, I used a Lifecycle Callback in the entity:
Location.php
/**
* #ORM\PreUpdate
*/
public function preventUpdate(PreUpdateEventArgs $args)
{
$address = $args->getOldValue('address');
$latitude =$args->getOldValue('latitude');
$longitude = $args->getOldValue('longitude');
$locality = $args->getOldValue('locality');
$country = $args->getOldValue('country');
$locationArray = array(
'address' => $address,
'latitude' => $latitude,
'longitude' => $longitude,
'locality' => $locality,
'country' => $country
);
$this->update($locationArray);
}
with the following function inside the Location.php entity:
public function update($location)
{
$data = $location;
$this->address = $data['address'] ?: null;
$this->latitude = $data['latitude'] ?: null;
$this->longitude = $data['longitude'] ?: null;
$this->locality = $data['locality'] ?: null;
$this->country = $data['country'] ?: null;
}
The problem is now, that I never can be able to update a Location.
Ok, I don´t now yet if I will need it.
But I would be grateful if there is another solution without this negative aspect.
I have two entities: User and CompanyInfo.
The relationship between both is oneToOne, the User can have zero or one CompanyInfo, and one CompanyInfo belongs to one User.
Therefore I setup them to have the same primary key (User's id):
class User extends BaseUser
{
/**
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* #ORM\OneToOne(targetEntity="CompanyInfo", mappedBy="user", cascade={"persist"})
* #var CompanyInfo
*/
protected $companyInfo;
...
}
class CompanyInfo
{
/**
* #ORM\OneToOne(targetEntity="User", inversedBy="companyInfo", cascade={"persist"})
* #ORM\JoinColumn(name="user_id", referencedColumnName="id")
* #ORM\Id
* #var User
*/
protected $user;
....
}
I'm having an issue trying to expose the them at the same time so that they can be updated by submitting only one form:
In the UserFormType I have the following line:
$builder->add('companyInfo', new CompanyInfoFormType(), ['required' => false, 'by_reference' => false])
The CompanyInfoFormType has the following:
/**
* #param OptionsResolverInterface $resolver
*/
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array(
'data_class' => '....\Entity\CompanyInfo',
'intention' => 'registration'
));
}
It all works fine, the form is rendered with both the user and the company info fields. When creating a new user & companyInfo it works but only because I did the following in the onSuccess of the UserFormHandler (Basically persist the User in first place, looks a bit hackie but couldn't find a nicer way):
if ($user->getCompanyInfo() instanceof CompanyInfo) {
$companyInfo = $user->getCompanyInfo()->setUser($user);
$user->setCompanyInfo(null);
$this->entityManager->beginTransaction();
$this->entityManager->persist($user);
$this->entityManager->flush();
$this->entityManager->persist($companyInfo);
$this->entityManager->flush();
$this->entityManager->commit();
$this->entityManager->refresh($user);
}
Now, the issue is when I'm trying to update a user that already has a companyInfo. For some weird reason, doctrine is thinking that the CompanyInfo entity doesn't exist and it's trying to do an INSERT rather than an UPDATE. It's like if the entity CompanyInfo it's not managed by Doctrine and therefore when doing the cascade persist, tries to create a new one.
I finally managed to find a solution for this, it's not ideal though, but it works. Basically, the process method of my UpdateFormHandler looks like follows:
/**
* #param UserInterface $user
* #return bool
*/
public function process(UserInterface $user)
{
$this->form->setData($user);
$method = $this->request->getMethod();
if (in_array($method, ['PUT', 'PATCH'])) {
$this->form->submit($this->request, 'PATCH' !== $method);
if ($this->form->isValid()) {
/** #var User $user */
$this->saveCompanyInfo($user);
$this->onSuccess($user);
$this->userManager->reloadUser($user);
return true;
}
}
return false;
}
/**
* Create link companyInfo -> User when persisting CompanyInfo for first time
*
* #param User $user
*/
protected function saveCompanyInfo(User $user)
{
if ($user->getCompanyInfo() instanceof CompanyInfo && !$user->getCompanyInfo()->getUser()) {
$user->getCompanyInfo()->setUser($user);
} elseif ($user->getCompanyInfo() instanceof CompanyInfo) {
/**
* If companyInfo exists and has been modified, doctrine things that it's a new entity
* detached from the manager, and will try to insert a new row on the company_info table (which crashes, as the PK (user_id) already exists).
* By calling ->merge, we obtain an attached/managed instance,
* so that it will be properly cascade persisted when the user is saved.
*/
/** #var CompanyInfo $companyInfo */
$companyInfo = $this->getEntityManager()->merge($user->getCompanyInfo());
$user->setCompanyInfo($companyInfo);
}
}
I'm sure (I hope) there are better ways, but I'm looking forward to hear them, as this is the only thing that worked for me.
I hope it helps.
Regards,
Javier
I'm having trouble in Doctrine-Fixtures. I'd like to add a user and a email in another entity, but in relation to the user. So here is my process:
// Create user
$user1 = new User();
// Create user email and add the foreign key to the user
$user1Mail = new UserEmail();
$user1Mail->setEmail('test#example.com');
$user1Mail->setUser($user1);
// Add attributes
$user1->setEmail($user1Mail);
// ...
$manager->persist($user1Mail);
$manager->persist($user1);
$manager->flush();
I add the user of the email in $user1Mail->setUser($user1); before the persist, but the problem is, the user has no primary key --> the ID (auto increment). So to create the relation between the email and the user, the user needs to have a primary key to refer to.
I know the solution to create a unique token before and set this to the ID of the user, but I think this is a uncomfortable way because I need to check if the user ID is already in use.
Is there a good way to handle this?
// EDIT:
Here is the necessary entity relation:
User:
class User implements UserInterface, \Serializable
{
// ...
/**
* #var Application\CoreBundle\Entity\UserEmail
*
* #ORM\OneToOne(
* targetEntity="UserEmail",
* cascade={"persist"}
* )
* #ORM\JoinColumn(
* name="primaryEmail",
* referencedColumnName="id",
* nullable=false,
* onDelete="restrict"
* )
*/
private $email;
// ...
}
UserEmail:
class UserEmail
{
// ...
/**
* #var Application\CoreBundle\Entity\User
* #ORM\ManyToOne(
* targetEntity="User",
* cascade={"persist", "remove"}
* )
* #ORM\JoinColumn(
* name="userID",
* referencedColumnName="id",
* nullable=false
* )
*/
private $user;
// ...
}
As you can see, if you add a user you have to add a UserEmail also. But the UserEmail requires that the userID is already set, but it is only set if you persist the user into the db. How can I realize a fix for it?
I find it strange to see that your User has a OneToOne association towards UserEmail, and UserEmail has a ManyToOne association towards User, and those are 2 separate associations.
I think you'd rather have a single bidirectional OneToMany association:
class User implements UserInterface, \Serializable
{
// ...
/**
* #var ArrayCollection
*
* #ORM\OneToMany(targetEntity="UserEmail", mappedBy="user", cascade={"persist", "remove"})
*/
private $emails;
public function __construct()
{
$this->emails = new ArrayCollection();
}
/**
* #param UserEmail $email
*/
public function addEmail(UserEmail $email)
{
$this->emails->add($email);
$email->setUser($this);
}
/**
* #param UserEmail $email
*/
public function removeEmail(UserEmail $email)
{
$this->emails->removeElement($email);
$email->setUser(null);
}
/**
* #return UserEmail[]
*/
public function getEmails()
{
return $this->emails->toArray();
}
// ...
}
class UserEmail
{
// ...
/**
* #var User
*
* #ORM\ManyToOne(targetEntity="User", inversedBy="emails")
* #ORM\JoinColumn(name="userID", referencedColumnName="id", nullable=FALSE)
*/
private $user;
/**
* #param User $user
*/
public setUser(User $user = null)
{
$this->user = $user;
}
/**
* #return User[]
*/
public function getUser()
{
return $this->user;
}
// ...
}
I've put a cascade on User::$emails, so any changes to User get cascaded towards UserEmail. This will make managing them easier.
Using this would look something like this:
$email = new UserEmail();
$user = new User();
$user->addEmail($email);
$em->persist($user);
$em->flush();
About foreign keys
Doctrine will manage the foreign keys of your entities for you. You don't need to manually set them on your entities when using associations.
Primary email
Personally I would add a property to UserEmail to mark it as primary. You'll need a bit more logic in the entities, but managing them will become effortless.
Here's the additional code you need:
class User
{
// ...
/**
* #param UserEmail $email
*/
public function addEmail(UserEmail $email)
{
$this->emails->add($email);
$email->setUser($this);
$this->safeguardPrimaryEmail();
}
/**
* #param UserEmail $email
*/
public function removeEmail(UserEmail $email)
{
$this->emails->removeElement($email);
$email->setUser(null);
$this->safeguardPrimaryEmail();
}
/**
* #param UserEmail $email
*/
public function setPrimaryEmail(UserEmail $newPrimaryEmail)
{
if (!$this->emails->contains($newPrimaryEmail)) {
throw new \InvalidArgumentException('Unknown email given');
}
foreach ($this->emails as $email) {
if ($email === $newPrimaryEmail) {
$email->setPrimary(true);
} else {
$email->setPrimary(false);
}
}
}
/**
* #return UserEmail|null
*/
public function getPrimaryEmail()
{
foreach ($this->emails as $email) {
if ($email->isPrimary()) {
return $email;
}
}
return null;
}
/**
* Make sure there's 1 and only 1 primary email (if there are any emails)
*/
private function safeguardPrimaryEmail()
{
$primaryFound = false;
foreach ($this->emails as $email) {
if ($email->isPrimary()) {
if ($primaryFound) {
// make sure there's no more than 1 primary email
$email->setPrimary(false);
} else {
$primaryFound = true;
}
}
}
if (!$primaryFound and !$this->emails->empty()) {
// make sure there's at least 1 primary email
$this->emails->first()->setPrimary(true);
}
}
// ...
}
class UserEmail
{
// ...
/**
* #var boolean
*
* #ORM\Column(type="boolean")
*/
private $isPrimary = false;
/**
* #internal Use
* #param bool $isPrimary
*/
public function setPrimary($isPrimary)
{
$this->isPrimary = (bool)$isPrimary;
}
/**
* #return bool
*/
public function isPrimary()
{
return $this->isPrimary;
}
// ...
}
You'll probably notice safeguardPrimaryEmail(). This will make sure the primary-mark will remain consistent when adding/removing emails.
Using this is very simple:
An email that's created is not primary by default.
If it's the first email added to a user, it will automatically become primary.
Additionally added emails will remain not primary.
When the primary email is removed, the first remaining email will become primary.
You can manually set another primary email by calling User::setPrimaryEmail().
There are many variations to this concept possible, so just view this as an example and refine it to your needs.
It's because Doctrine will generate the entity id when it's inserted into the database.
You can do it with an extra flush():
$user1 = new User();
$manager->persist($user1);
$manager->flush();
// Create user email and add the foreign key to the user
$user1Mail = new UserEmail();
$user1Mail->setEmail('test#example.com');
$user1Mail->setUser($user1);
// Add attributes
$user1->setEmail($user1Mail);
// ...
$manager->persist($user1Mail);
$manager->persist($user1);
$manager->flush();
Or you can set the email mapping in your User class to cascade persist.
It means that if a new not persisted object is added to that object, then the new object will be saved as well.
I don't know the exact structure of the entites, but it would look like
/**
* #ORM\OneToOne(targetEntity="user", cascade={"persist"})
* #ORM\JoinColumn(name="user_email_id", referencedColumnName="id")
*/
private $userEmail
So if you set a new e-mail to the user it will be auto-persisted if you persist the User entity.
I would prefer the second method if it works. I hope it will help.
Doctrine reference: Transitive persistence / Cascade Operations
I had a big time trying to figure out how to setup a ManyToOne -> OneToMany relationship with Doctrine 2 and it still not working...
Here is the application behaviour:
A site has Pages
A User can write Comment on a Page
Here are my Entities (simplified):
Comment Entity:
**
* #ORM\Entity
* #ORM\Table(name="comment")
*/
class Comment {
/**
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* Many Comments have One User
*
* #ORM\ManyToOne(targetEntity="\Acme\UserBundle\Entity\User", inversedBy="comments")
*/
protected $user;
/**
* Many Comments have One Page
*
* #ORM\ManyToOne(targetEntity="\Acme\PageBundle\Entity\Page", inversedBy="comments")
*/
protected $page;
...
/**
* Set user
*
* #param \Acme\UserBundle\Entity\User $user
* #return Comment
*/
public function setUser(\Acme\UserBundle\Entity\User $user)
{
$this->user = $user;
return $this;
}
/**
* Set page
*
* #param \Acme\PageBundle\Entity\Page $page
* #return Comment
*/
public function setPage(\Acme\PageBundle\Entity\Page $page)
{
$this->page = $page;
return $this;
}
User Entity:
/**
* #ORM\Entity
* #ORM\Table(name="fos_user")
*/
class User extends BaseUser
{
/**
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* The User create the Comment so he's supposed to be the owner of this relationship
* However, Doctrine doc says: "The many side of OneToMany/ManyToOne bidirectional relationships must be the owning
* side", so Comment is the owner
*
* One User can write Many Comments
*
* #ORM\OneToMany(targetEntity="Acme\CommentBundle\Entity\Comment", mappedBy="user")
*/
protected $comments;
...
/**
* Get Comments
*
* #return \Doctrine\Common\Collections\Collection
*/
public function getComments() {
return $this->comments ?: $this->comments = new ArrayCollection();
}
Page Entity:
/**
* #ORM\Entity
* #ORM\Table(name="page")
*/
class Page
{
/**
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* One Page can have Many Comments
* Owner is Comment
*
* #ORM\OneToMany(targetEntity="\Acme\CommentBundle\Entity\Comment", mappedBy="page")
*/
protected $comments;
...
/**
* #return \Doctrine\Common\Collections\Collection
*/
public function getComments(){
return $this->comments ?: $this->comments = new ArrayCollection();
}
I want a bidirectional relationship to be able to get the collection of Comments from the Page or from the User (using getComments()).
My problem is that when I try to save a new Comment, I get an error saying that doctrine is not able to create a Page entity. I guess this is happening because it's not finding the Page (but it should) so it's trying to create a new Page entity to later link it to the Comment entity that I'm trying to create.
Here is the method from my controller to create a Comment:
public function createAction()
{
$user = $this->getUser();
$page = $this->getPage();
$comment = new EntityComment();
$form = $this->createForm(new CommentType(), $comment);
if ($this->getRequest()->getMethod() === 'POST') {
$form->bind($this->getRequest());
if ($form->isValid()) {
$em = $this->getDoctrine()->getManager();
$comment->setPage($page);
$comment->setUser($user);
$em->persist($comment);
$em->flush();
return $this->redirect($this->generateUrl('acme_comment_listing'));
}
}
return $this->render('AcmeCommentBundle:Default:create.html.twig', array(
'form' => $form->createView()
));
}
I don't understand why this is happening. I've checked my Page object in this controller (returned by $this->getPage() - which return the object stored in session) and it's a valid Page entity that exists (I've checked in the DB too).
I don't know what to do now and I can't find anyone having the same problem :(
This is the exact error message I have:
A new entity was found through the relationship
'Acme\CommentBundle\Entity\Comment#page' that was not configured to
cascade persist operations for entity:
Acme\PageBundle\Entity\Page#000000005d8a1f2000000000753399d4. To solve
this issue: Either explicitly call EntityManager#persist() on this
unknown entity or configure cascade persist this association in the
mapping for example #ManyToOne(..,cascade={"persist"}). If you cannot
find out which entity causes the problem implement
'Acme\PageBundle\Entity\Page#__toString()' to get a clue.
But I don't want to add cascade={"persist"} because I don't want to create the page on cascade, but just link the existing one.
UPDATE1:
If I fetch the page before to set it, it's working. But I still don't know why I should.
public function createAction()
{
$user = $this->getUser();
$page = $this->getPage();
// Fetch the page from the repository
$page = $this->getDoctrine()->getRepository('AcmePageBundle:page')->findOneBy(array(
'id' => $page->getId()
));
$comment = new EntityComment();
// Set the relation ManyToOne
$comment->setPage($page);
$comment->setUser($user);
$form = $this->createForm(new CommentType(), $comment);
if ($this->getRequest()->getMethod() === 'POST') {
$form->bind($this->getRequest());
if ($form->isValid()) {
$em = $this->getDoctrine()->getManager();
$em->persist($comment);
$em->flush();
return $this->redirect($this->generateUrl('acme_comment_listing'));
}
}
return $this->render('AcmeCommentBundle:Default:create.html.twig', array(
'form' => $form->createView()
));
}
UPDATE2:
I've ended up storing the page_id in the session (instead of the full object) which I think is a better idea considering the fact that I won't have a use session to store but just the id. I'm also expecting Doctrine to cache the query when retrieving the Page Entity.
But can someone explain why I could not use the Page entity from the session? This is how I was setting the session:
$pages = $site->getPages(); // return doctrine collection
if (!$pages->isEmpty()) {
// Set the first page of the collection in session
$session = $request->getSession();
$session->set('page', $pages->first());
}
Actually, your Page object is not known by the entity manager, the object come from the session. (The correct term is "detached" from the entity manager.)
That's why it tries to create a new one.
When you get an object from different source, you have to use merge function. (from the session, from an unserialize function, etc...)
Instead of
// Fetch the page from the repository
$page = $this->getDoctrine()->getRepository('AcmePageBundle:page')->findOneBy(array(
'id' => $page->getId()
));
You can simply use :
$page = $em->merge($page);
It will help you if you want to work with object in your session.
More information on merging entities here