DoctrineExtensions/lib/Gedmo/Uploadable/Mapping/Validator.php

<?php

namespace Gedmo\Uploadable\Mapping;

use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Gedmo\Exception\InvalidMappingException;
use Gedmo\Exception\UploadableCantWriteException;
use Doctrine\ORM\Mapping\ClassMetadata;

/**
 * This class is used to validate mapping information
 *
 * @author Gustavo Falco <comfortablynumb84@gmail.com>
 * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
 * @package Gedmo.Uploadable.Mapping
 * @subpackage Validator
 * @link http://www.gediminasm.org
 * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
 */

class Validator 
{
    const UPLOADABLE_FILE_MIME_TYPE = 'UploadableFileMimeType';
    const UPLOADABLE_FILE_PATH = 'UploadableFilePath';
    const UPLOADABLE_FILE_SIZE = 'UploadableFileSize';
    const FILENAME_GENERATOR_SHA1 = 'SHA1';
    const FILENAME_GENERATOR_ALPHANUMERIC = 'ALPHANUMERIC';
    const FILENAME_GENERATOR_NONE = 'NONE';

    /**
     * List of types which are valid for UploadableFileMimeType field
     *
     * @var array
     */
    public static $validFileMimeTypeTypes = array(
        'string'
    );

    /**
     * List of types which are valid for UploadableFilePath field
     *
     * @var array
     */
    public static $validFilePathTypes = array(
        'string'
    );

    /**
     * List of types which are valid for UploadableFileSize field
     *
     * @var array
     */
    public static $validFileSizeTypes = array(
        'decimal'
    );


    public static function validateFileMimeTypeField(ClassMetadataInfo $meta, $field)
    {
        self::validateField($meta, $field, self::UPLOADABLE_FILE_MIME_TYPE, self::$validFileMimeTypeTypes);
    }

    public static function validateFilePathField(ClassMetadataInfo $meta, $field)
    {
        self::validateField($meta, $field, self::UPLOADABLE_FILE_PATH, self::$validFilePathTypes);
    }

    public static function validateFileSizeField(ClassMetadataInfo $meta, $field)
    {
        self::validateField($meta, $field, self::UPLOADABLE_FILE_SIZE, self::$validFileSizeTypes);
    }

    public static function validateField($meta, $field, $uploadableField, $validFieldTypes)
    {
        $fieldMapping = $meta->getFieldMapping($field);

        if (!in_array($fieldMapping['type'], $validFieldTypes)) {
            $msg = 'Field "%s" to work as an "%s" field must be of one of the following types: "%s".';

            throw new InvalidMappingException(sprintf($msg,
                $field,
                $uploadableField,
                explode(', ', $validFieldTypes)
            ));
        }
    }

    public static function validatePath($path)
    {
        if (!is_dir($path) || !is_writable($path)) {
            throw new UploadableCantWriteException(sprintf('Directory "%s" does not exist or is not writable',
                $path
            ));
        }
    }

    public static function validateConfiguration(ClassMetadata $meta, array $config)
    {
        $refl = $meta->getReflectionClass();

        if (!$config['filePathField']) {
            throw new InvalidMappingException(sprintf('Class "%s" must have an UploadableFilePath field.',
                $meta->name
            ));
        }

        if ($config['pathMethod'] !== '') {
            if (!$refl->hasMethod($config['pathMethod'])) {
                throw new InvalidMappingException(sprintf('Class "%s" doesn\'t have method "%s"!',
                    $meta->name,
                    $config['pathMethod']
                ));
            }
        }

        if ($config['callback'] !== '') {
            if (!$refl->hasMethod($config['callback'])) {
                throw new InvalidMappingException(sprintf('Class "%s" doesn\'t have method "%s"!',
                    $meta->name,
                    $config['callback']
                ));
            }
        }

        if ($config['fileMimeTypeField']) {
            self::validateFileMimeTypeField($meta, $config['fileMimeTypeField']);
        }

        if ($config['fileSizeField']) {
            self::validateFileSizeField($meta, $config['fileSizeField']);
        }

        switch ((string) $config['filenameGenerator']) {
            case self::FILENAME_GENERATOR_ALPHANUMERIC:
            case self::FILENAME_GENERATOR_SHA1:
            case self::FILENAME_GENERATOR_NONE:
                break;
            default:
                $ok = false;
                if (is_class($config['filenameGenerator'])) {
                    $refl = new \ReflectionClass($config['filenameGenerator']);

                    if ($refl->implementsInterface('Gedmo\Uploadable\FilenameGeneratorInterface')) {
                        $ok = true;
                    }
                }

                if (!$ok) {
                    $msg = 'Class "%s" needs a valid value for filenameGenerator. It can be: SHA1, ALPHANUMERIC, NONE or ';
                    $msg .= 'a class implementing FileGeneratorInterface.';

                    throw new InvalidMappingException(sprintf($msg,
                        $meta->name
                    ));
                }
        }

        self::validateFilePathField($meta, $config['filePathField']);
    }
}