File

Warning: You are browsing the documentation for Symfony 3.x, which is no longer maintained.

Read the updated version of this page for Symfony 7.2 (the current stable version).

Validates that a value is a valid "file", which can be one of the following:

A string (or object with a __toString() method) path to an existing file;
A valid File object (including objects of UploadedFile class).

This constraint is commonly used in forms with the FileType form field.

Tip

If the file you're validating is an image, try the Image constraint.

Applies to	property or method
Options	maxSize binaryFormat mimeTypes maxSizeMessage mimeTypesMessage disallowEmptyMessage notFoundMessage notReadableMessage uploadIniSizeErrorMessage uploadFormSizeErrorMessage uploadPartialErrorMessage uploadNoFileErrorMessage uploadNoTmpDirErrorMessage uploadCantWriteErrorMessage uploadExtensionErrorMessage uploadErrorMessage payload groups
Class	File
Validator	FileValidator

Basic Usage

This constraint is most commonly used on a property that will be rendered in a form as a FileType field. For example, suppose you're creating an author form where you can upload a "bio" PDF for the author. In your form, the bioFile property would be a file type. The Author class might look as follows:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        // src/AppBundle/Entity/Author.php
namespace AppBundle\Entity;

use Symfony\Component\HttpFoundation\File\File;

class Author
{
    protected $bioFile;

    public function setBioFile(File $file = null)
    {
        $this->bioFile = $file;
    }

    public function getBioFile()
    {
        return $this->bioFile;
    }
}
    

To guarantee that the bioFile File object is valid and that it is below a certain file size and a valid PDF, add the following:

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        // src/AppBundle/Entity/Author.php
namespace AppBundle\Entity;

use Symfony\Component\Validator\Constraints as Assert;

class Author
{
    /**
     * @Assert\File(
     *     maxSize = "1024k",
     *     mimeTypes = {"application/pdf", "application/x-pdf"},
     *     mimeTypesMessage = "Please upload a valid PDF"
     * )
     */
    protected $bioFile;
}
    

        1
2
3
4
5
6
7
8
        # src/AppBundle/Resources/config/validation.yml
AppBundle\Entity\Author:
    properties:
        bioFile:
            - File:
                maxSize: 1024k
                mimeTypes: [application/pdf, application/x-pdf]
                mimeTypesMessage: Please upload a valid PDF
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        <!-- src/AppBundle/Resources/config/validation.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping https://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">

    <class name="AppBundle\Entity\Author">
        <property name="bioFile">
            <constraint name="File">
                <option name="maxSize">1024k</option>
                <option name="mimeTypes">
                    <value>application/pdf</value>
                    <value>application/x-pdf</value>
                </option>
                <option name="mimeTypesMessage">Please upload a valid PDF</option>
            </constraint>
        </property>
    </class>
</constraint-mapping>
    

        1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
        // src/AppBundle/Entity/Author.php
namespace AppBundle\Entity;

use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;

class Author
{
    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraint('bioFile', new Assert\File([
            'maxSize' => '1024k',
            'mimeTypes' => [
                'application/pdf',
                'application/x-pdf',
            ],
            'mimeTypesMessage' => 'Please upload a valid PDF',
        ]));
    }
}
    

The bioFile property is validated to guarantee that it is a real file. Its size and mime type are also validated because the appropriate options have been specified.

Note

As with most of the other constraints, null and empty strings are considered valid values. This is to allow them to be optional values. If the value is mandatory, a common solution is to combine this constraint with NotBlank.

Options

`maxSize`

type: mixed

If set, the size of the underlying file must be below this file size in order to be valid. The size of the file can be given in one of the following formats:

Suffix	Unit Name	value	e.g.
	byte	1 byte	`4096`
k	kilobyte	1,000 bytes	`200k`
M	megabyte	1,000,000 bytes	`2M`
Ki	kibibyte	1,024 bytes	`32Ki`
Mi	mebibyte	1,048,576 bytes	`8Mi`

For more information about the difference between binary and SI prefixes, see Wikipedia: Binary prefix.

`binaryFormat`

type: boolean default: null

When true, the sizes will be displayed in messages with binary-prefixed units (KiB, MiB). When false, the sizes will be displayed with SI-prefixed units (kB, MB). When null, the binaryFormat will be guessed from the value defined in the maxSize option.

For more information about the difference between binary and SI prefixes, see Wikipedia: Binary prefix.

`mimeTypes`

type: array or string

If set, the validator will check that the mime type of the underlying file is equal to the given mime type (if a string) or exists in the collection of given mime types (if an array).

You can find a list of existing mime types on the IANA website.

`maxSizeMessage`

type: string default: The file is too large ({{ size }} {{ suffix }}). Allowed maximum size is {{ limit }} {{ suffix }}.

The message displayed if the file is larger than the maxSize option.

You can use the following parameters in this message:

Parameter	Description
`{{ size }}`	File size of the given file
`{{ limit }}`	Maximum file size allowed
`{{ suffix }}`	Suffix for the used file size unit (see above)
`{{ file }}`	Absolute file path

`mimeTypesMessage`

type: string default: The mime type of the file is invalid ({{ type }}). Allowed mime types are {{ types }}.

The message displayed if the mime type of the file is not a valid mime type per the mimeTypes option.

You can use the following parameters in this message:

Parameter	Description
`{{ type }}`	The MIME type of the given file
`{{ types }}`	The list of allowed MIME types
`{{ file }}`	Absolute file path

`disallowEmptyMessage`

type: string default: An empty file is not allowed.

This constraint checks if the uploaded file is empty (i.e. 0 bytes). If it is, this message is displayed.

You can use the following parameters in this message:

Parameter	Description
`{{ file }}`	Absolute file path

`notFoundMessage`

type: string default: The file could not be found.

The message displayed if no file can be found at the given path. This error is only likely if the underlying value is a string path, as a File object cannot be constructed with an invalid file path.

You can use the following parameters in this message:

Parameter	Description
`{{ file }}`	Absolute file path

`notReadableMessage`

type: string default: The file is not readable.

The message displayed if the file exists, but the PHP is_readable() function fails when passed the path to the file.

You can use the following parameters in this message:

Parameter	Description
`{{ file }}`	Absolute file path

`uploadIniSizeErrorMessage`

type: string default: The file is too large. Allowed maximum size is {{ limit }} {{ suffix }}.

The message that is displayed if the uploaded file is larger than the upload_max_filesize php.ini setting.

You can use the following parameters in this message:

Parameter	Description
`{{ limit }}`	Maximum file size allowed
`{{ suffix }}`	Suffix for the used file size unit (see above)

`uploadFormSizeErrorMessage`

type: string default: The file is too large.

The message that is displayed if the uploaded file is larger than allowed by the HTML file input field.