How to return a Zip file in Symfony

Introduction

Handling file downloads, especially creating and returning zip files dynamically, is a common requirement in web development. In this tutorial, we’ll explore how to generate and return a zip file in a Symfony application. Symfony, a powerful PHP framework, provides an elegant and robust solution for such tasks.

Before diving in, make sure that your Symfony project is set up and running. For this guide, it’s assumed that you have a basic understanding of Symfony’s structure and its controllers.

Basic Zip File Creation and Download

First, let’s start by creating a simple zip file and returning it in a response. We’ll use the ZipArchive class that PHP provides.

use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use ZipArchive;

public function downloadZipAction()
{
    $zip = new ZipArchive();
    $zipName = tempnam(sys_get_temp_dir(), 'zip');
    $zip->open($zipName, ZipArchive::CREATE);
    $zip->addFromString('test.txt', 'file content here');
    $zip->close();

    $response = new BinaryFileResponse($zipName);
    $response->headers->set('Content-Type', 'application/zip');
    $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, 'archive.zip');

    return $response;
}

This code snippet creates a temporary zip file, adds a text file with content, then returns it using Symfony’s BinaryFileResponse. Your users can now download this file as archive.zip when they access the route connected to this action.

Advanced Zip File Generation

In more complex scenarios, you might need to add multiple files or directories to the zip. You’ll also need to ensure the selected files exist and handle potential errors gracefully. Let’s refactor the code to create a more advanced zip downloading functionality:

use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use ZipArchive;
use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;

public function downloadAdvancedZipAction()
{
    $zip = new ZipArchive();
    $zipName = tempnam(sys_get_temp_dir(), 'zip');

    if ($zip->open($zipName, ZipArchive::CREATE) !== true) {
        throw new \RuntimeException('Cannot open ' . $zipName);
    }

    // Add multiple files
    $files = ['path/to/file1.txt', 'path/to/file2.jpg'];
    foreach ($files as $file) {
        if (file_exists($file)) {
            $zip->addFile($file, basename($file));
        } else {
            throw new NotFoundHttpException('File not found: ' . $file);
        }
    }

    // Add an entire directory
    $directoryPath = 'path/to/directory';
    if (is_dir($directoryPath)) {
        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($directoryPath),
            RecursiveIteratorIterator::LEAVES_ONLY
        );

        foreach ($files as $name => $file) {
            // Skip directories (they would be added automatically)
            if (!$file->isDir()) {
                // Get real path for current file
                $filePath = $file->getRealPath();

                // Add current file to archive
                $zip->addFile($filePath, $file->getFilename());
            }
        }
    } else {
        throw new NotFoundHttpException('Directory not found: ' . $directoryPath);
    }

    $zip->close();

    $response = new BinaryFileResponse($zipName);
    $response->headers->set('Content-Type', 'application/zip');
    $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, 'advanced_archive.zip');

    return $response;
}

The adjusted action dynamically adds files from an array and a directory to a new zip archive. It opens up a new temporary file as a zip and loops over the files and directory, adding each to the zip while checking if the file or directory exists first. Appropriate HTTP exceptions are thrown when there is an issue with file or directory existence.

Error Handling and Cleanup

Creating temporary files on a server could mean taking up space and potentially causing storage issues. It’s crucial to handle the cleanup process well. One way to do this is by removing the temporary file after the user has started the download:

public function downloadAndCleanupAction()
{
    //... [Create zip logic here] ...

    // Return response and delete file after download is sent
    $response->deleteFileAfterSend(true);

    return $response;
}

The deleteFileAfterSend(true) method of the BinaryFileResponse object ensures that the temporary file gets deleted as soon as the response is sent to the user.

Conclusion

This guide has shown how to handle the task of dynamically creating and returning zip files in a Symfony application. Starting with simple file operations, we advanced to handling directories, error management, and automatic cleanup. By following the practices outlined here, you can efficiently integrate zip file functionality into your Symfony applications.