class.ilFileDataMail.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */


use ILIAS\Filesystem\Filesystem;

require_once("./Services/FileSystem/classes/class.ilFileData.php");
require_once("./Services/Utilities/classes/class.ilFileUtils.php");

class ilFileDataMail extends ilFileData
{
    public $user_id;

    public $mail_path;

    protected $mail_max_upload_file_size;

    protected $tmpDirectory;

    protected $storageDirectory;

    protected $db;

    public function __construct($a_user_id = 0)
    {
        global $DIC;

        define('MAILPATH', 'mail');
        parent::__construct();
        $this->mail_path = parent::getPath() . "/" . MAILPATH;
        $this->checkReadWrite();
        $this->user_id = $a_user_id;

        $this->db = $DIC->database();
        $this->tmpDirectory = $DIC->filesystem()->temp();
        $this->storageDirectory = $DIC->filesystem()->storage();

        $this->initAttachmentMaxUploadSize();
    }

    public function initDirectory()
    {
        if (is_writable($this->getPath())) {
            if (mkdir($this->getPath() . '/' . MAILPATH)) {
                if (chmod($this->getPath() . '/' . MAILPATH, 0755)) {
                    $this->mail_path = $this->getPath() . '/' . MAILPATH;
                    return true;
                }
            }
        }
        return false;
    }

    public function getUploadLimit()
    {
        return $this->mail_max_upload_file_size;
    }

    public function getAttachmentsTotalSizeLimit()
    {
        $max_size = $this->ilias->getSetting('mail_maxsize_attach', '');
        if (!strlen($max_size)) {
            return null;
        }

        return (float) $this->ilias->getSetting('mail_maxsize_attach', 0) * 1024;
    }

    public function getMailPath()
    {
        return $this->mail_path;
    }

    public function getAbsoluteAttachmentPoolPathPrefix() : string
    {
        return $this->mail_path . '/' . $this->user_id . '_';
    }

    public function getAttachmentPathAndFilenameByMd5Hash(string $md5FileHash, int $mailId) : array
    {
        $res = $this->db->queryF(
            "SELECT path FROM mail_attachment WHERE mail_id = %s",
            ['integer'],
            [$mailId]
        );

        if (1 !== (int) $this->db->numRows($res)) {
            throw new \OutOfBoundsException();
        }

        $row = $this->db->fetchAssoc($res);

        $relativePath = $row['path'];
        $path = $this->getMailPath() . '/' . $row['path'];

        $files = ilUtil::getDir($path);
        foreach ($files as $file) {
            if ($file['type'] === 'file' && md5($file['entry']) === $md5FileHash) {
                return [
                    'path' => $this->getMailPath() . '/' . $relativePath . '/' . $file['entry'],
                    'filename' => $file['entry']
                ];
            }
        }

        throw new \OutOfBoundsException();
    }

    private function getAttachmentPathByMailId(int $mailId) : string
    {
        $query = $this->db->query(
            "SELECT path FROM mail_attachment WHERE mail_id = " . $this->db->quote($mailId, 'integer')
        );

        while ($row = $this->db->fetchObject($query)) {
            return $row->path;
        }

        return '';
    }

    public function getAttachmentPath($a_filename, $a_mail_id)
    {
        $path = $this->getMailPath() . '/' . $this->getAttachmentPathByMailId($a_mail_id) . '/' . $a_filename;

        if (file_exists($path) && is_readable($path)) {
            return $path;
        }

        return '';
    }
    public function adoptAttachments($a_attachments, $a_mail_id)
    {
        if (is_array($a_attachments)) {
            foreach ($a_attachments as $file) {
                $path = $this->getAttachmentPath($file, $a_mail_id);
                if (!copy($path, $this->getMailPath() . '/' . $this->user_id . '_' . $file)) {
                    return "ERROR: $this->getMailPath().'/'.$this->user_id.'_'.$file cannot be created";
                }
            }
        } else {
            return "ARRAY REQUIRED";
        }
        return '';
    }

    public function checkReadWrite()
    {
        if (is_writable($this->mail_path) && is_readable($this->mail_path)) {
            return true;
        } else {
            $this->ilias->raiseError("Mail directory is not readable/writable by webserver: " . $this->mail_path, $this->ilias->error_obj->FATAL);
        }
    }
    public function getUserFilesData()
    {
        return $this->getUnsentFiles();
    }

    private function getUnsentFiles()
    {
        $files = array();

        $iter = new DirectoryIterator($this->mail_path);
        foreach ($iter as $file) {
            if ($file->isFile()) {
                list($uid, $rest) = explode('_', $file->getFilename(), 2);
                if ($uid == $this->user_id) {
                    $files[] = array(
                        'name' => $rest,
                        'size' => $file->getSize(),
                        'ctime' => $file->getCTime()
                    );
                }
            }
        }

        return $files;
    }
    
    public function storeAsAttachment($a_filename, $a_content)
    {
        if (strlen($a_content) >= $this->getUploadLimit()) {
            return 1;
        }

        $name = ilUtil::_sanitizeFilemame($a_filename);
        $this->rotateFiles($this->getMailPath() . '/' . $this->user_id . '_' . $name);

        $abs_path = $this->getMailPath() . '/' . $this->user_id . '_' . $name;
        
        if (!$fp = @fopen($abs_path, 'w+')) {
            return false;
        }
        if (@fwrite($fp, $a_content) === false) {
            @fclose($fp);
            return false;
        }
        @fclose($fp);
        return true;
    }
    
    public function storeUploadedFile($file)
    {
        $file['name'] = ilUtil::_sanitizeFilemame($file['name']);

        $this->rotateFiles($this->getMailPath() . '/' . $this->user_id . '_' . $file['name']);

        ilUtil::moveUploadedFile(
            $file['tmp_name'],
            $file['name'],
            $this->getMailPath() . '/' . $this->user_id . '_' . $file['name']
        );
    }

    public function copyAttachmentFile($a_abs_path, $a_new_name)
    {
        @copy($a_abs_path, $this->getMailPath() . "/" . $this->user_id . "_" . $a_new_name);
        
        return true;
    }
        


    public function rotateFiles($a_path)
    {
        if (file_exists($a_path)) {
            $this->rotateFiles($a_path . ".old");
            return \ilFileUtils::rename($a_path, $a_path . '.old');
        }
        return true;
    }
    public function unlinkFiles($a_filenames)
    {
        if (is_array($a_filenames)) {
            foreach ($a_filenames as $file) {
                if (!$this->unlinkFile($file)) {
                    return $file;
                }
            }
        }
        return '';
    }
    public function unlinkFile($a_filename)
    {
        if (file_exists($this->mail_path . '/' . basename($this->user_id . '_' . $a_filename))) {
            return unlink($this->mail_path . '/' . basename($this->user_id . '_' . $a_filename));
        }
    }

    public function getAbsoluteAttachmentPoolPathByFilename(string $fileName) : string
    {
        return $this->getAbsoluteAttachmentPoolPathPrefix() . $fileName;
    }

    public function saveFiles($a_mail_id, array $a_attachments)
    {
        if (!is_numeric($a_mail_id) || $a_mail_id < 1) {
            throw new InvalidArgumentException('The passed mail_id must be a valid integer!');
        }

        foreach ($a_attachments as $attachment) {
            $this->saveFile($a_mail_id, $attachment);
        }
    }

    public static function getStorage($a_mail_id, $a_usr_id) : \ilFSStorageMail
    {
        static $fsstorage_cache = array();
        
        if (!is_object($fsstorage_cache[$a_mail_id][$a_usr_id])) {
            include_once 'Services/Mail/classes/class.ilFSStorageMail.php';
            $fsstorage_cache[$a_mail_id][$a_usr_id] = new ilFSStorageMail($a_mail_id, $a_usr_id);
        }
        
        return $fsstorage_cache[$a_mail_id][$a_usr_id];
    }
    
    public function saveFile($a_mail_id, $a_attachment)
    {
        $oStorage = self::getStorage($a_mail_id, $this->user_id);
        $oStorage->create();
        $storage_directory = $oStorage->getAbsolutePath();
                
        if (@!is_dir($storage_directory)) {
            return false;
        }
        
        return copy(
            $this->mail_path . '/' . $this->user_id . '_' . $a_attachment,
            $storage_directory . '/' . $a_attachment
        );
    }
    public function checkFilesExist($a_files)
    {
        if ($a_files) {
            foreach ($a_files as $file) {
                if (!file_exists($this->mail_path . '/' . $this->user_id . '_' . $file)) {
                    return false;
                }
            }
            return true;
        }
        return true;
    }
    public function assignAttachmentsToDirectory($a_mail_id, $a_sent_mail_id)
    {
        global $ilDB;
        
        /*              $query = "INSERT INTO mail_attachment ".
                    "SET mail_id = ".$ilDB->quote($a_mail_id).", ".
                    "path = ".$ilDB->quote($this->user_id."_".$a_sent_mail_id)." ";
                $res = $this->ilias->db->query($query);
        */

        $oStorage = self::getStorage($a_sent_mail_id, $this->user_id);
        $res = $ilDB->manipulateF(
            '
                        INSERT INTO mail_attachment 
                        ( mail_id, path) VALUES (%s, %s)',
            array('integer', 'text'),
            array($a_mail_id, $oStorage->getRelativePathExMailDirectory())
        );
    }
    public function deassignAttachmentFromDirectory($a_mail_id)
    {
        global $ilDB;
        // IF IT'S THE LAST MAIL CONTAINING THESE ATTACHMENTS => DELETE ATTACHMENTS
        $res = $ilDB->query("SELECT path FROM mail_attachment
                                WHERE mail_id = " . $ilDB->quote($a_mail_id, 'integer'));
    
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $path = $row->path;
        }
        if ($path) {
            $res = $ilDB->query("SELECT COUNT(mail_id) count_mail_id FROM mail_attachment 
                                        WHERE path = " . $ilDB->quote($path, 'text')) ;
            
            while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                $cnt_mail_id = $row->count_mail_id;
            }
            if ($cnt_mail_id == 1) {
                $this->__deleteAttachmentDirectory($path);
            }
        }

        $res = $ilDB->manipulateF(
            "DELETE FROM mail_attachment 
                                WHERE mail_id = %s",
            array('integer'),
            array($a_mail_id)
        );
        return true;
    }

    public function __deleteAttachmentDirectory($a_rel_path)
    {
        ilUtil::delDir($this->mail_path . "/" . $a_rel_path);
        
        return true;
    }

    protected function initAttachmentMaxUploadSize()
    {
        // Copy of ilFileInputGUI: begin
        // get the value for the maximal uploadable filesize from the php.ini (if available)
        $umf = ini_get("upload_max_filesize");
        // get the value for the maximal post data from the php.ini (if available)
        $pms = ini_get("post_max_size");

        //convert from short-string representation to "real" bytes
        $multiplier_a = array("K" => 1024, "M" => 1024 * 1024, "G" => 1024 * 1024 * 1024);

        $umf_parts = preg_split("/(\d+)([K|G|M])/", $umf, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
        $pms_parts = preg_split("/(\d+)([K|G|M])/", $pms, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);

        if (count($umf_parts) == 2) {
            $umf = $umf_parts[0] * $multiplier_a[$umf_parts[1]];
        }
        if (count($pms_parts) == 2) {
            $pms = $pms_parts[0] * $multiplier_a[$pms_parts[1]];
        }

        // use the smaller one as limit
        $max_filesize = min($umf, $pms);

        if (!$max_filesize) {
            $max_filesize = max($umf, $pms);
        }
        // Copy of ilFileInputGUI: end

        $this->mail_max_upload_file_size = $max_filesize;
    }

    public static function _lookupDiskUsageOfUser($user_id)
    {
        // XXX - This method is extremely slow. We should
        // use a cache to speed it up, for example, we should
        // store the disk space used in table mail_attachment.
        global $DIC;

        $mail_data_dir = ilUtil::getDataDir('filesystem') . DIRECTORY_SEPARATOR . "mail";

        $q = "SELECT path " .
            "FROM mail_attachment ma " .
            "JOIN mail m ON ma.mail_id=m.mail_id " .
            "WHERE m.user_id = " . $DIC->database()->quote($user_id);
        $result_set = $DIC->database()->query($q);
        $size = 0;
        $count = 0;
        while ($row = $result_set->fetchRow(ilDBConstants::FETCHMODE_ASSOC)) {
            $attachment_path = $mail_data_dir . DIRECTORY_SEPARATOR . $row['path'];
            $attachment_size = ilUtil::dirsize($attachment_path);
            if ($attachment_size != -1) {
                $size += $attachment_size;
            }
            $count++;
        }
        return array('count' => $count, 'size' => $size);
    }

    public function onUserDelete()
    {
        global $ilDB;
        
        // Delete uploaded mail files which are not attached to any message
        try {
            $iter = new RegexIterator(
                new DirectoryIterator($this->getMailPath()),
                '/^' . $this->user_id . '_/'
            );
            foreach ($iter as $file) {
                if ($file->isFile()) {
                    @unlink($file->getPathname());
                }
            }
        } catch (Exception $e) {
        }

        // Select all files attached to messages which are not shared (... = 1) with other messages anymore
        $query = '
                        SELECT DISTINCT(ma1.path)
                        FROM mail_attachment ma1
                        INNER JOIN mail
                                ON mail.mail_id = ma1.mail_id
                        WHERE mail.user_id = %s
                        AND (SELECT COUNT(tmp.path) FROM mail_attachment tmp WHERE tmp.path = ma1.path) = 1
                ';
        $res = $ilDB->queryF(
            $query,
            array('integer'),
            array($this->user_id)
        );
        while ($row = $ilDB->fetchAssoc($res)) {
            try {
                $path = $this->getMailPath() . DIRECTORY_SEPARATOR . $row['path'];
                $iter = new RecursiveIteratorIterator(
                    new RecursiveDirectoryIterator($path),
                    RecursiveIteratorIterator::CHILD_FIRST
                );
                foreach ($iter as $file) {
                    if ($file->isDir()) {
                        @rmdir($file->getPathname());
                    } else {
                        @unlink($file->getPathname());
                    }
                }
                @rmdir($path);
            } catch (Exception $e) {
            }
        }

        // Delete each mail attachment rows assigned to a message of the deleted user.
        $ilDB->manipulateF(
            '
                                DELETE
                                FROM mail_attachment
                                WHERE EXISTS(
                                        SELECT mail.mail_id
                                        FROM mail
                                        WHERE mail.user_id = %s AND mail.mail_id = mail_attachment.mail_id
                                )
                                ',
            array('integer'),
            array($this->user_id)
        );
    }

    public function deliverAttachmentsAsZip(string $basename, int $mailId, $files = [], $isDraft = false)
    {
        $path = '';
        if (!$isDraft) {
            $path = $this->getAttachmentPathByMailId($mailId);
            if (0 === strlen($path)) {
                throw new \ilException('mail_download_zip_no_attachments');
            }
        }

        $downloadFilename = \ilUtil::getASCIIFilename($basename);
        if (0 === strlen($downloadFilename)) {
            $downloadFilename = 'attachments';
        }

        $processingDirectory = \ilUtil::ilTempnam();
        $relativeProcessingDirectory = basename($processingDirectory);

        $absoluteZipDirectory = $processingDirectory . '/' . $downloadFilename;
        $relativeZipDirectory = $relativeProcessingDirectory . '/' . $downloadFilename;

        $this->tmpDirectory->createDir($relativeZipDirectory);

        foreach ($files as $fileName) {
            if ($isDraft) {
                $source = str_replace(
                    $this->mail_path,
                    MAILPATH,
                    $this->getAbsoluteAttachmentPoolPathByFilename($fileName)
                );
            } else {
                $source = MAILPATH . '/' . $path . '/' . $fileName;
            }

            $source = str_replace('//', '/', $source);
            if (!$this->storageDirectory->has($source)) {
                continue;
            }

            $target = $relativeZipDirectory . '/' . $fileName;

            $stream = $this->storageDirectory->readStream($source);
            $this->tmpDirectory->writeStream($target, $stream);
        }

        $pathToZipFile = $processingDirectory . '/' . $downloadFilename . '.zip';
        \ilUtil::zip($absoluteZipDirectory, $pathToZipFile);

        $this->tmpDirectory->deleteDir($relativeZipDirectory);

        $delivery = new \ilFileDelivery($processingDirectory . '/' . $downloadFilename . '.zip');
        $delivery->setDisposition(\ilFileDelivery::DISP_ATTACHMENT);
        $delivery->setMimeType(\ilMimeTypeUtil::APPLICATION__ZIP);
        $delivery->setConvertFileNameToAsci(true);
        $delivery->setDownloadFileName(\ilFileUtils::getValidFilename($downloadFilename . '.zip'));
        $delivery->setDeleteFile(true);

        $delivery->deliver();
    }
}