filesystem = $filesystemMap->get(static::FS_KEY); } /** * Return true if the file exists in the file storage. */ public function exists(File $file): bool { return $this->filesystem->has($file->getSlug()); } /** * Lists all the non-temporary files of the given owner. * * @return list */ public function listByOwner( Organization|Access|Person $owner, ?FileTypeEnum $type = null, ): array { return $this->filesystem->listKeys( $this->getPrefix($owner, false, $type) ); } /** * Reads the given file and returns its content as a string. */ public function read(File $file): string { return $this->filesystem->read($file->getSlug()); } /** * Retourne l'URL de l'image, à la bonne taille, contenu dans le File. */ public function getImageUrl(File $file, string $size, bool $relativePath, bool $uncropped = false): string { $crop = !empty($file->getConfig()) && !$uncropped; $filterName = $this->getFilterFromSizeAndConfig($size, $crop); $path = $file->getSlug(); if (!$this->cacheManager->isStored($path, $filterName)) { try { $this->imageFactory->createImageContent($file, $filterName, $uncropped); } catch (\Exception $e) { $path = 'images/missing-file.png'; return $relativePath ? $path : $this->urlBuilder->getAbsoluteUrl($path); } } $url = $this->cacheManager->resolve($path, $filterName); return $relativePath ? $this->urlBuilder->getRelativeUrl($url) : $url; } /** * Retourne le filtre Liip correspondant à la taille désirée. */ protected function getFilterFromSizeAndConfig(string $size, bool $crop = true): string { switch ($size) { case FileSizeEnum::SM->value : $filter = $crop ? self::CROP_SM : self::SM_FOLDER; break; case FileSizeEnum::MD->value : default: $filter = $crop ? self::CROP_MD : self::MD_FOLDER; break; case FileSizeEnum::LG->value : $filter = $crop ? self::CROP_LG : self::LG_FOLDER; break; } return $filter; } /** * Prepare a File record with a PENDING status. * This record will hold all the data needed to create the file, except its content. * * @param Organization|Access|Person $owner Owner of the file, either an organization, a person or both (access) * @param string $filename The file's name (mandatory) * @param FileTypeEnum $type The type of the new file * @param Access $createdBy Id of the access responsible for this creation * @param bool $isTemporary Is it a temporary file that can be deleted after some time * @param string|null $mimeType Mimetype of the file, if not provided, the method will try to guess it from its file name's extension * @param bool $flushFile Should the newly created file be flushed after having been persisted? * @param FileFolderEnum|null $folder The folder where the file is stored, designed for document management */ public function prepareFile( Organization|Access|Person $owner, string $filename, FileTypeEnum $type, Access $createdBy, bool $isTemporary = false, FileVisibilityEnum $visibility = FileVisibilityEnum::NOBODY, ?string $mimeType = null, bool $flushFile = true, ?FileFolderEnum $folder = FileFolderEnum::UNRATED, ): File { [$organization, $person] = $this->getOrganizationAndPersonFromOwner($owner); $file = (new File()) ->setName($filename) ->setSlug(null) ->setOrganization($organization) ->setPerson($person) ->setType($type) ->setVisibility($visibility) ->setIsTemporaryFile($isTemporary) ->setMimeType($mimeType ?? $this->fileUtils->guessMimeTypeFromFilename($filename)) ->setCreateDate(new \DateTime()) ->setCreatedBy($createdBy->getId()) ->setFolder($folder) ->setStatus(FileStatusEnum::PENDING); $this->entityManager->persist($file); if ($flushFile) { $this->entityManager->flush(); } return $file; } /** * Write the $content into the file storage and update the given File object's size, slug, status (READY)... * * @param File $file The file object that is about to be written * @param string $content The content of the file * @param Access $author The access responsible for the creation / update of the file */ public function write(File $file, string $content, Access $author): File { if (empty($file->getName())) { throw new \RuntimeException('File has no filename'); } try { $isNewFile = $file->getSlug() === null; } catch (\Throwable) { $isNewFile = true; // Catch case where slud has not been initialized } if ($isNewFile) { // Try to get the Access owner from the organization_id and person_id $access = null; if ($file->getOrganization() !== null && $file->getPerson() !== null) { $access = $this->accessRepository->findOneBy( ['organization' => $file->getOrganization(), 'person' => $file->getPerson()] ); } $prefix = $this->getPrefix( $access ?? $file->getOrganization() ?? $file->getPerson(), $file->getIsTemporaryFile(), $file->getType() ); $uid = date('Ymd_His').'_'.Uuid::uuid(5); $key = PathUtils::join($prefix, $uid, $file->getName()); } else { $key = $file->getSlug(); } if (!$isNewFile && !$this->filesystem->has($key)) { throw new \RuntimeException('The file `'.$key.'` does not exist in the file storage'); } $size = $this->filesystem->write($key, $content, true); $file->setSize($size) ->setStatus(FileStatusEnum::READY); if ($isNewFile) { $file->setSlug($key) ->setCreateDate(new \DateTime()) ->setCreatedBy($author->getId()); } else { $file->setUpdateDate(new \DateTime()) ->setUpdatedBy($author->getId()); } $this->entityManager->flush(); return $file; } /** * Convenient method to successively prepare and write a file. */ public function makeFile( Organization|Access|Person $owner, string $filename, FileTypeEnum $type, string $content, Access $author, bool $isTemporary = false, FileVisibilityEnum $visibility = FileVisibilityEnum::NOBODY, ?string $mimeType = null, ?string $config = null, ?FileFolderEnum $folder = FileFolderEnum::UNRATED, ): File { $file = $this->prepareFile( $owner, $filename, $type, $author, $isTemporary, $visibility, $mimeType, false, $folder, ); if (!empty($config)) { // TODO: Déplacer dans le prepareFile? $file->setConfig($config); } return $this->write($file, $content, $author); } /** * Uupdate the status of the File. */ public function softDelete(File $file, Access $author): File { $file->setStatus(FileStatusEnum::DELETED) ->setSize(0) ->setUpdatedBy($author->getId()); return $file; } /** * Delete the given file from the filesystem. */ public function hardDelete(File $file): void { $deleted = $this->filesystem->delete($file->getSlug()); if (!$deleted) { throw new \RuntimeException('File `'.$file->getSlug().'` could\'nt be deleted'); } } /** * Permanently delete the entire file storage of the given Organization. */ public function deleteOrganizationFiles(int $organizationId): void { $this->rrmDir('organization/'.$organizationId); $this->rrmDir('temp/organization/'.$organizationId); } /** * Permanently delete the entire file storage of the given Person. */ public function deletePersonFiles(int $personId): void { $this->rrmDir('person/'.$personId); $this->rrmDir('temp/person/'.$personId); } /** * Supprime récursivement un répertoire. * * (Au moment du développement, Gaufrette ne permet pas la suppression de répertoires) */ protected function rrmDir(string $dirKey): void { if (!$this->filesystem->isDirectory($dirKey)) { throw new \RuntimeException('Directory `'.$dirKey.'` does not exist'); } $dir = PathUtils::join($this->fileStorageDir, $dirKey); $this->fileUtils->rmTree($dir); } /** * If an organization owns the file, the prefix will be '(_temp_/)organization/{id}(/{type})'. * If a person owns it, the prefix will be '(_temp_/)person/{id}(/{type})' * If access owns it, the prefix will be '(_temp_/)organization/{organization_id}/{access_id}(/{type})'. * * With {id} being the id of the organization or of the person. * * If the file is temporary, '_temp_/' is prepended to the prefix. * If a file type is given, this type is appended to the prefix (low case) */ protected function getPrefix( Organization|Access|Person $owner, bool $isTemporary, ?FileTypeEnum $type = null, ): string { if ($owner instanceof Access) { $prefix = PathUtils::join('organization', $owner->getOrganization()?->getId(), $owner->getId()); } elseif ($owner instanceof Organization) { $prefix = PathUtils::join('organization', $owner->getId()); } else { $prefix = PathUtils::join('person', $owner->getId()); } if ($isTemporary) { $prefix = PathUtils::join('temp', $prefix); } if ($type !== null && $type !== FileTypeEnum::NONE) { $prefix = PathUtils::join($prefix, strtolower($type->value)); } return $prefix; } /** * Return an array [$organization, $person] from a given owner. * * @return list */ #[Pure] protected function getOrganizationAndPersonFromOwner(Organization|Access|Person $owner): array { if ($owner instanceof Access) { return [$owner->getOrganization(), $owner->getPerson()]; } if ($owner instanceof Organization) { return [$owner, null]; } return [null, $owner]; } public function support(File $file): bool { return $file->getHost() === FileHostEnum::AP2I; } }