upgrade

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/Mapping/Driver/Annotation.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Gedmo\Uploadable\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\AbstractAnnotationDriver;
+use Gedmo\Uploadable\Mapping\Validator;
+
+/**
+ * This is an annotation mapping driver for Uploadable
+ * behavioral extension. Used for extraction of extended
+ * metadata from Annotations specifically for Uploadable
+ * extension.
+ *
+ * @author Gustavo Falco <comfortablynumb84@gmail.com>
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Annotation extends AbstractAnnotationDriver
+{
+    /**
+     * Annotation to define that this object is loggable
+     */
+    const UPLOADABLE = 'Gedmo\\Mapping\\Annotation\\Uploadable';
+    const UPLOADABLE_FILE_MIME_TYPE = 'Gedmo\\Mapping\\Annotation\\UploadableFileMimeType';
+    const UPLOADABLE_FILE_NAME = 'Gedmo\\Mapping\\Annotation\\UploadableFileName';
+    const UPLOADABLE_FILE_PATH = 'Gedmo\\Mapping\\Annotation\\UploadableFilePath';
+    const UPLOADABLE_FILE_SIZE = 'Gedmo\\Mapping\\Annotation\\UploadableFileSize';
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        $class = $this->getMetaReflectionClass($meta);
+
+        // class annotations
+        if ($annot = $this->reader->getClassAnnotation($class, self::UPLOADABLE)) {
+            $config['uploadable'] = true;
+            $config['allowOverwrite'] = $annot->allowOverwrite;
+            $config['appendNumber'] = $annot->appendNumber;
+            $config['path'] = $annot->path;
+            $config['pathMethod'] = $annot->pathMethod;
+            $config['fileMimeTypeField'] = false;
+            $config['fileNameField'] = false;
+            $config['filePathField'] = false;
+            $config['fileSizeField'] = false;
+            $config['callback'] = $annot->callback;
+            $config['filenameGenerator'] = $annot->filenameGenerator;
+            $config['maxSize'] = (double) $annot->maxSize;
+            $config['allowedTypes'] = $annot->allowedTypes;
+            $config['disallowedTypes'] = $annot->disallowedTypes;
+
+            foreach ($class->getProperties() as $prop) {
+                if ($this->reader->getPropertyAnnotation($prop, self::UPLOADABLE_FILE_MIME_TYPE)) {
+                    $config['fileMimeTypeField'] = $prop->getName();
+                }
+
+                if ($this->reader->getPropertyAnnotation($prop, self::UPLOADABLE_FILE_NAME)) {
+                    $config['fileNameField'] = $prop->getName();
+                }
+
+                if ($this->reader->getPropertyAnnotation($prop, self::UPLOADABLE_FILE_PATH)) {
+                    $config['filePathField'] = $prop->getName();
+                }
+
+                if ($this->reader->getPropertyAnnotation($prop, self::UPLOADABLE_FILE_SIZE)) {
+                    $config['fileSizeField'] = $prop->getName();
+                }
+            }
+
+            Validator::validateConfiguration($meta, $config);
+        }
+
+        /*
+        // Code in case we need to identify entities which are not Uploadables, but have associations
+        // with other Uploadable entities
+
+        } else {
+            // We need to check if this class has a relation with Uploadable entities
+            $associations = $meta->getAssociationMappings();
+
+            foreach ($associations as $field => $association) {
+                $refl = new \ReflectionClass($association['targetEntity']);
+
+                if ($annot = $this->reader->getClassAnnotation($refl, self::UPLOADABLE)) {
+                    $config['hasUploadables'] = true;
+
+                    if (!isset($config['uploadables'])) {
+                        $config['uploadables'] = array();
+                    }
+
+                    $config['uploadables'][] = array(
+                        'class'         => $association['targetEntity'],
+                        'property'      => $association['fieldName']
+                    );
+                }
+            }
+        }*/
+
+        $this->validateFullMetadata($meta, $config);
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/Mapping/Driver/Xml.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Gedmo\Uploadable\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\Xml as BaseXml;
+use Gedmo\Uploadable\Mapping\Validator;
+
+/**
+ * This is a xml mapping driver for Uploadable
+ * behavioral extension. Used for extraction of extended
+ * metadata from xml specifically for Uploadable
+ * extension.
+ *
+ * @author Gustavo Falco <comfortablynumb84@gmail.com>
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Miha Vrhovnik <miha.vrhovnik@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Xml extends BaseXml
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        /**
+         * @var \SimpleXmlElement $xml
+         */
+        $xml = $this->_getMapping($meta->name);
+        $xmlDoctrine = $xml;
+        $xml = $xml->children(self::GEDMO_NAMESPACE_URI);
+
+        if ($xmlDoctrine->getName() == 'entity' || $xmlDoctrine->getName() == 'mapped-superclass') {
+            if (isset($xml->uploadable)) {
+                $xmlUploadable = $xml->uploadable;
+                $config['uploadable'] = true;
+                $config['allowOverwrite'] = $this->_isAttributeSet($xmlUploadable, 'allow-overwrite') ?
+                    (bool) $this->_getAttribute($xmlUploadable, 'allow-overwrite') : false;
+                $config['appendNumber'] = $this->_isAttributeSet($xmlUploadable, 'append-number') ?
+                    (bool) $this->_getAttribute($xmlUploadable, 'append-number') : false;
+                $config['path'] = $this->_isAttributeSet($xmlUploadable, 'path') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'path') : '';
+                $config['pathMethod'] = $this->_isAttributeSet($xmlUploadable, 'path-method') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'path-method') : '';
+                $config['callback'] = $this->_isAttributeSet($xmlUploadable, 'callback') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'callback') : '';
+                $config['fileMimeTypeField'] = false;
+                $config['fileNameField'] = false;
+                $config['filePathField'] = false;
+                $config['fileSizeField'] = false;
+                $config['filenameGenerator'] = $this->_isAttributeSet($xmlUploadable, 'filename-generator') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'filename-generator') :
+                    Validator::FILENAME_GENERATOR_NONE;
+                $config['maxSize'] = $this->_isAttributeSet($xmlUploadable, 'max-size') ?
+                    (double) $this->_getAttribute($xml->{'uploadable'}, 'max-size') :
+                    (double) 0;
+                $config['allowedTypes'] = $this->_isAttributeSet($xmlUploadable, 'allowed-types') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'allowed-types') :
+                    '';
+                $config['disallowedTypes'] = $this->_isAttributeSet($xmlUploadable, 'disallowed-types') ?
+                    $this->_getAttribute($xml->{'uploadable'}, 'disallowed-types') :
+                    '';
+
+                if (isset($xmlDoctrine->field)) {
+                    foreach ($xmlDoctrine->field as $mapping) {
+                        $mappingDoctrine = $mapping;
+                        $mapping = $mapping->children(self::GEDMO_NAMESPACE_URI);
+
+                        $field = $this->_getAttribute($mappingDoctrine, 'name');
+
+                        if (isset($mapping->{'uploadable-file-mime-type'})) {
+                            $config['fileMimeTypeField'] = $field;
+                        } elseif (isset($mapping->{'uploadable-file-size'})) {
+                            $config['fileSizeField'] = $field;
+                        } elseif (isset($mapping->{'uploadable-file-name'})) {
+                            $config['fileNameField'] = $field;
+                        } elseif (isset($mapping->{'uploadable-file-path'})) {
+                            $config['filePathField'] = $field;
+                        }
+                    }
+                }
+
+                Validator::validateConfiguration($meta, $config);
+            }
+        }
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Uploadable/Mapping/Driver/Yaml.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Gedmo\Uploadable\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\File;
+use Gedmo\Mapping\Driver;
+use Gedmo\Uploadable\Mapping\Validator;
+
+/**
+ * This is a yaml mapping driver for Uploadable
+ * behavioral extension. Used for extraction of extended
+ * metadata from yaml specifically for Uploadable
+ * extension.
+ *
+ * @author Gustavo Falco <comfortablynumb84@gmail.com>
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Yaml extends File implements Driver
+{
+    /**
+     * File extension
+     * @var string
+     */
+    protected $_extension = '.dcm.yml';
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        $mapping = $this->_getMapping($meta->name);
+
+        if (isset($mapping['gedmo'])) {
+            $classMapping = $mapping['gedmo'];
+
+            if (isset($classMapping['uploadable'])) {
+                $uploadable = $classMapping['uploadable'];
+
+                $config['uploadable'] = true;
+                $config['allowOverwrite'] = isset($uploadable['allowOverwrite']) ?
+                    (bool) $uploadable['allowOverwrite'] : false;
+                $config['appendNumber'] = isset($uploadable['appendNumber']) ?
+                    (bool) $uploadable['appendNumber'] : false;
+                $config['path'] = isset($uploadable['path']) ? $uploadable['path'] : '';
+                $config['pathMethod'] = isset($uploadable['pathMethod']) ? $uploadable['pathMethod'] : '';
+                $config['callback'] = isset($uploadable['callback']) ? $uploadable['callback'] : '';
+                $config['fileMimeTypeField'] = false;
+                $config['fileNameField'] = false;
+                $config['filePathField'] = false;
+                $config['fileSizeField'] = false;
+                $config['filenameGenerator'] = isset($uploadable['filenameGenerator']) ?
+                    $uploadable['filenameGenerator'] :
+                    Validator::FILENAME_GENERATOR_NONE;
+                $config['maxSize'] = isset($uploadable['maxSize']) ?
+                    (double) $uploadable['maxSize'] :
+                    (double) 0;
+                $config['allowedTypes'] = isset($uploadable['allowedTypes']) ?
+                    $uploadable['allowedTypes'] :
+                    '';
+                $config['disallowedTypes'] = isset($uploadable['disallowedTypes']) ?
+                    $uploadable['disallowedTypes'] :
+                    '';
+
+                if (isset($mapping['fields'])) {
+                    foreach ($mapping['fields'] as $field => $info) {
+                        if (isset($info['gedmo']) && array_key_exists(0, $info['gedmo'])) {
+                            if ($info['gedmo'][0] === 'uploadableFileMimeType') {
+                                $config['fileMimeTypeField'] = $field;
+                            } elseif ($info['gedmo'][0] === 'uploadableFileSize') {
+                                $config['fileSizeField'] = $field;
+                            } elseif ($info['gedmo'][0] === 'uploadableFileName') {
+                                $config['fileNameField'] = $field;
+                            } elseif ($info['gedmo'][0] === 'uploadableFilePath') {
+                                $config['filePathField'] = $field;
+                            }
+                        }
+                    }
+                }
+
+                Validator::validateConfiguration($meta, $config);
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _loadMappingFile($file)
+    {
+        return \Symfony\Component\Yaml\Yaml::parse(file_get_contents($file));
+    }
+}