Moving entities across collections in Doctrine - php

Question

This question is a bit related, to my other question here
ArrayCollection ( Doctrine ) contains function returns incorrect results , so if anyone wants more information about my problem, it is there, although this is not strictly the same problem.
Now, to the point, I have a FileSystemFolder that models a folder, and a FileProxy that models a File, FileSystemFolder contains an ArrayCollection of FileProxy, I also have a FileManager, that performs a move operation, something that you would expect to have on any FileSystem. This move operation takes two FileSystemFolder and a FileProxy, removes this FileProxy from one FileSystemFolder and adds it into another FileSystemFolder.
Here is this function, in all its glory:
public function moveFileProxy(FileSystemFolder $from, FileSystemFolder $to, FileProxy $proxy, $force = false)
{
if (!$this->checkFolder($from))
{
return array('type' => 'error', 'message' => 'Cannot move from this folder.');
}
if (!$force)
{
if (!$this->checkFolder($to))
{
return array('type' => 'error', 'message' => 'Cannot move to this folder.');
}
}
/*$return = "";
foreach($from->getFiles() as $file)
{
$return .= $file->getFilename() . " --- ";
}
if(!$from->getFiles()->contains($proxy))
{
return array('type' => 'error', 'message' => 'Folder '.$from->getName().' does not contain '.$proxy->getFilename(). ' All files from this folder '. $return);
}
if($to->getFiles()->contains($proxy))
{
return array('type' => 'error', 'message' => 'Folder '.$to->getName().' already contains '.$proxy->getFilename());
}*/
$from->removeFile($proxy);
$to->addFile($proxy);
return array('type' => 'pass', 'message' => 'Operation Successful.');
}
The commented out piece of code belongs to the other question. Checks do not matter.
For the sake of this question, I'll copy one piece of information from that other question, because it is important, here it is:
/**
* #ORM\ManyToMany(targetEntity="FileProxy", fetch="EXTRA_LAZY")
* #ORM\JoinTable(name="file_system_folders_files",
* joinColumns={#ORM\JoinColumn(name="file_system_folder_id", referencedColumnName="id")},
* inverseJoinColumns={#ORM\JoinColumn(name="proxy_id", referencedColumnName="id", unique=true)})
*/
protected $files;
and this:
/**
* Add proxy
*
* #param FileProxy $proxy
* #return FileSystemFolder
*/
public function addFile(FileProxy $proxy)
{
if(!$this->getFiles()->contains($proxy))
{
$this->getFiles()->add($proxy);
}
return $this;
}
/**
* Remove proxy
*
* #param FileProxy $proxy
* #return FileSystemFolder
*/
public function removeFile(FileProxy $proxy)
{
if($this->getFiles()->contains($proxy))
{
$this->getFiles()->removeElement($proxy);
}
return $this;
}
Now, these functions are exteremely straightforward, they really do not do anything fancy, exactly what their names tell, and the funny thing is,
the moveFileProxy function works perfectly fine ( I persist both folders out of this function, which I think is a good practice ).
The question is: Should this function actually work ? As you can see, the $files variable, which is an ArrayCollection does not cascade persist, it doesn't cascade anything, yet this function still works.
Here is a piece of code showing the whole process:
$result = $fm->moveFileProxy($origin, $destination, $upload);
if($result['type'] === 'error')
{
return JsonResponse::create($result);
}
$em = $this->getDoctrine()->getManager();
$em->persist($origin);
$em->persist($destination);
$em->flush();
But it works just most of the time, it does not throw errors most of the time, but sometimes, on some weird occassions, it throws "Duplicate entry exception" which is also weird, because this is after all a move operation.
If you know anything about this problem, please help me, #symfony and #doctrine IRCs are really awful at helping.
Thanks.

Answer 1

It would seem, that I discovered what might be the answer to this question ( completely by accident ), bare in mind, that I am not entirely sure, and I do not think it is documented in Doctrine Documentation. It might be buried somewhere in the code, and I might look that up later to prove this theory.
My theory is:
Unidirectional Many-To-Many associations create an additional table, so that the association is composed of 3 tables, with no actual Many-To-Many association, the 2 tables are obviously the ones you used to form the association, but the third one is important.
The third table is created by Doctrine on the spot, and even though we specify the properties for the columns with #JoinColumn, I think Doctrine actually modyfies them further to cascade persist, because it would make no real sense otherwise.
I am also pretty sure, that it actually cascades all, but like I said, it's just a theory.