Symfony Different Validation for different usage cases on same entity - php

Question

So I have a Document Entity that stores file uploads (currently only Images) that is used all over the project which is a blog. Now for the article I want to be able to upload and select an Image that basically has little to no restriction apart from file size, but for a category I want to only be able to use Images that are square or not landscape and not portrait.
The Document Entity looks like this
class Document
{
/**
* #var integer
*/
private $id;
/**
* Get id
*
* #return integer
*/
public function getId()
{
return $this->id;
}
/**
* #var string
*/
private $name;
/**
* #var string
*/
private $path;
private $webPath;
private $filename;
/**
* Set name
*
* #param string $name
* #return Document
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* Get name
*
* #return string
*/
public function getName()
{
return $this->name;
}
/**
* Set path
*
* #param string $path
* #return Document
*/
public function setPath($path)
{
$this->path = $path;
return $this;
}
/**
* Get path
*
* #return string
*/
public function getPath()
{
return $this->path;
}
public function setFullFilename()
{
$this->filename = $this->id . '.' . $this->path;
}
public function getFilename()
{
return $this->filename;
}
public function getAbsolutePath()
{
//return null === $this->path ? null : $this->getUploadRootDir(). '/' . $this->path;
return null === $this->path ? null : $this->getUploadRootDir().'/'.$this->id.'.'.$this->path;
}
public function getWebPath()
{
return null === $this->path ? null : $this->getUploadDir() . '/';
}
public function getUploadRootDir()
{
return __DIR__.'/../../../../web/'.$this->getUploadDir();
}
public function getUploadDir()
{
return 'bundles/pgblog/images/uploads';
}
private $file;
private $temp;
public function setFile(UploadedFile $file = null)
{
$this->file = $file;
if(is_file($this->getAbsolutePath()))
{
$this->temp = $this->getAbsolutePath();
}
else {
$this->path = 'initial';
}
}
public function getFile()
{
return $this->file;
}
public function preUpload()
{
if(null !== $this->getFile())
{
$this->path = $this->getFile()->guessExtension();
$this->setMimetype();
$this->setSize();
/*
$filename = sha1(uniqid(mt_rand(), true));
$this->path = $filename . '.' . $this->getFile()->guessExtension();
*/
}
}
public function upload()
{
if(null === $this->getFile())
{
return;
}
if(isset($this->temp))
{
unlink($this->temp);
$this->temp = null;
}
$this->getFile()->move($this->getUploadRootDir(), $this->id . '.' . $this->getFile()->guessExtension());
$this->file = null;
}
public function storeFilenameForRemove()
{
$this->temp = $this->getAbsolutePath();
}
public function removeUpload()
{
if(isset($this->temp))
{
unlink($this->temp);
}
}
public function __toString()
{
return $this->name;
}
/**
* #var string
*/
private $mimetype;
/**
* Set mimetype
*
* #param string $mimetype
* #return Document
*/
public function setMimetype()
{
$this->mimetype = $this->getFile()->getMimeType();
return $this;
}
/**
* Get mimetype
*
* #return string
*/
public function getMimetype()
{
return $this->mimetype;
}
/**
* #var integer
*/
private $size;
/**
* Set size
*
* #param integer $size
* #return Document
*/
public function setSize()
{
$this->size = $this->getFile()->getSize();
return $this;
}
/**
* Get size
*
* #return integer
*/
public function getSize()
{
return $this->size;
}
}
I use seperate forms for file upload and article/category creation. When creating an article or category, a file can be chosen from a list of currently all Files
Here the form type for Article
class ArticleType extends AbstractType
{
...
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
->add('title')
->add('text')
->add('tags')
->add('category')
->add('image')
;
}
...
}
and the article entity
class Article
{
...
/**
* Set image
*
* #param \Acme\UtilBundle\Entity\Document $image
* #return Article
*/
public function setImage(\PG\BlogBundle\Entity\Document $image = null)
{
$this->image = $image;
return $this;
}
/**
* Get image
*
* #return \Acme\BlogBundle\Entity\Document
*/
public function getImage()
{
return $this->image;
}
}
Article is related to Document via a unidirectional many to one relationship
manyToOne:
image:
targetEntity: Document
joinColumn:
name: document_id
referencedColumnName: id
So in the form the files can be set by a select. For the article this is just fine, since I want to be able to use any image as an attachment, but for the categories I want only the files that are square as I said earlier.
I thought about using validation for the category image, but since the Image is selected by a select, the actual data is just a string (the file name given on the upload form) and not the image it self so the validation returns the error
Catchable Fatal Error: Argument 1 passed to Acme\BlogBundle\Entity\Category::setImage() must be an instance of Acme\BlogBundle\Entity\Document, string given...
So my question is, how do I restrict the Image options in the category form to only square images and how do I validate this properly?
The reason I only want to use square Images for category is so I can display a nice symmetric list of all the cateogries by the way.
Thanks in advance!

Answer 1

Store the image dimensions in your document entity (length, width).
That way when fetching the document collection for category forms you can filter image documents where length == width, so only display appropriate documents.
For validation, you have a number of options, the best place to start would be here. In your place I'd look into validation groups.