/** * Returns a list of uploadable fields for the given object and mapping. * * @param mixed $object The object to use. * * @return array<string> A list of field names. */ protected function getUploadableFields($object) { $fields = $this->metadata->getUploadableFields(ClassUtils::getClass($object), $this->mapping); return array_map(function ($data) { return $data['propertyName']; }, $fields); }
/** * Dans le cas d'un document nouvellement enregistré, je vais renommer le nom du fichier uploadé si besoin * @param LifecycleEventArgs $eventArgs [description] * @return [type] [description] */ public function postPersist(LifecycleEventArgs $eventArgs) { $document = $eventArgs->getDocument(); $dm = $eventArgs->getDocumentManager(); $is_uploadable = $this->metadata_reader->isUploadable(ClassUtils::getClass($document)); if ($is_uploadable) { // Récupération des champs uploadable $fields = $this->metadata_reader->getUploadableFields(ClassUtils::getClass($document)); // Pour chacun de ces champs, je récupère le mapping associé pour vérifier le namer et le nom du champ foreach ($fields as $field) { $mapping = $this->mapping_factory->fromField($document, $field['propertyName']); if ($mapping->getNamer() instanceof \Redking\Bundle\UploadBundle\Naming\ObjectNamer) { $filename = $mapping->getFileName($document); $file = $mapping->getFile($document); // Si il y a bien un fichier, je vérifie son nom if (!is_null($filename) && $file instanceof File) { $filename_normalized = $mapping->getNamer()->getNormalizedName($document, $filename); // Si les deux noms ne correspondent pas, je renomme et réassigne if (strcmp($filename, $filename_normalized) !== 0) { $base_directory = $mapping->hasDirectoryNamer() ? $mapping->getDirectoryNamer()->directoryName($document, $mapping) . '/' : ''; $adapter = $this->filesystem_map->get($mapping->getUploadDestination())->getAdapter(); $adapter->rename($base_directory . $filename, $base_directory . $filename_normalized); if ($adapter->exists($base_directory . $filename)) { $adapter->delete($base_directory . $filename); } // On vérifie si il y a des fichiers resized à renommer foreach ($this->resizes as $suffix => $resize_conf) { $resize_filename = $base_directory . ResizedNamer::getName($filename, $suffix); $resize_filename_normalized = $base_directory . ResizedNamer::getName($filename_normalized, $suffix); if ($adapter->exists($resize_filename)) { $adapter->rename($resize_filename, $resize_filename_normalized); if ($adapter->exists($resize_filename)) { $adapter->delete($resize_filename); } } } $mapping->setFileName($document, $filename_normalized); // Ré-enregistrement $class = $dm->getClassMetadata(get_class($document)); $dm->getUnitOfWork()->recomputeSingleDocumentChangeSet($class, $document); } } } // Traitement du répertoire basé sur l'id pour voir si le fichier est bien dedans $directory_namer = $mapping->getDirectoryNamer(); if (!is_null($directory_namer) && $directory_namer instanceof BaseDirectoryIdNamer) { $adapter = $this->filesystem_map->get($mapping->getUploadDestination())->getAdapter(); $filename = $mapping->getFileName($document); $good_path = ltrim($directory_namer->directoryName($document, $mapping) . '/' . $filename, '/'); $bad_path = ltrim($directory_namer->directoryNameError($document, $mapping) . '/' . $filename, '/'); if (!$adapter->exists($good_path) && $adapter->exists($bad_path)) { $success = $adapter->rename($bad_path, $good_path); } } } } }
/** * Creates an array of PropetyMapping objects which contain the * configuration for the uploadable fields in the specified * object. * * @param object $obj The object. * @param string $className The object's class. Mandatory if $obj can't be used to determine it. * * @return array An array up PropertyMapping objects. */ public function fromObject($obj, $className = null) { if ($obj instanceof Proxy) { $obj->__load(); } $class = $this->getClassName($obj, $className); $this->checkUploadable($class); $mappings = array(); foreach ($this->metadata->getUploadableFields($class) as $field => $mappingData) { $mappings[$mappingData['mapping']] = $this->createMapping($obj, $field, $mappingData); } return $mappings; }
/** * @param PreSerializeEvent $event */ public function onPreSerializeFile(PreSerializeEvent $event) { $entity = $event->getObject(); $type = $event->getType(); $className = $type['name']; $request = $this->requestStack->getCurrentRequest(); $isUploadable = $this->metadataReader->isUploadable($className); if (!$isUploadable) { return; } $cacheKey = md5($className . '_' . $entity->getId()); if (isset(self::$cache[$cacheKey])) { return; } self::$cache[$cacheKey] = true; $uploadableFields = $this->metadataReader->getUploadableFields($className); foreach ($uploadableFields as $uploadableField) { $propertyName = $uploadableField['propertyName']; $fileNameProperty = $uploadableField['fileNameProperty']; $getterFile = 'get' . $fileNameProperty; if ($entity->{$getterFile}()) { $setterFile = 'set' . $fileNameProperty; $originUrl = $this->uploaderHelper->asset($entity, $propertyName); if ($originUrl) { /** @var ImagineFilters $imagineFiltersAnnotation */ $reflectionClass = new \ReflectionClass($className); $imagineFiltersAnnotation = $this->annotationsReader->getPropertyAnnotation($reflectionClass->getProperty($fileNameProperty), new ImagineFilters()); if ($imagineFiltersAnnotation) { $urls = []; foreach ($imagineFiltersAnnotation->getFilters() as $filter) { $urls[$filter] = $this->imagineHelper->filter($originUrl, $filter); } $property = $imagineFiltersAnnotation->getProperty(); $entity->{$property} = $urls; } } if ($request) { $originUrl = $request->getSchemeAndHttpHost() . $originUrl; } $entity->{$setterFile}($originUrl); } } }