filestore.php

Go to the documentation of this file.

<?php

use Symfony\Component\HttpFoundation\File\UploadedFile;

function get_dir_size($dir, $total_size = 0) {
    $handle = @opendir($dir);
    while ($file = @readdir($handle)) {
        if (in_array($file, array('.', '..'))) {
            continue;
        }
        if (is_dir($dir . $file)) {
            $total_size = get_dir_size($dir . $file . "/", $total_size);
        } else {
            $total_size += filesize($dir . $file);
        }
    }
    @closedir($handle);

    return($total_size);
}

function get_uploaded_file($input_name) {
    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated and will be removed', '2.3');
    $inputs = elgg_get_uploaded_files($input_name);
    $input = array_shift($inputs);
    if (!$input || !$input->isValid()) {
        return false;
    }
    return file_get_contents($input->getPathname());
}

function elgg_save_resized_image($source, $destination = null, array $params = array()) {
    return _elgg_services()->imageService->resize($source, $destination, $params);
}

function get_resized_image_from_uploaded_file($input_name, $maxwidth, $maxheight,
        $square = false, $upscale = false) {

    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated. Use elgg_save_resized_image()', '2.3');

    $files = _elgg_services()->request->files;
    if (!$files->has($input_name)) {
        return false;
    }

    $file = $files->get($input_name);
    if (empty($file)) {
        // a file input was provided but no file uploaded
        return false;
    }
    if ($file->getError() !== 0) {
        return false;
    }

    return get_resized_image_from_existing_file($file->getPathname(), $maxwidth, $maxheight, $square, 0, 0, 0, 0, $upscale);
}

function get_resized_image_from_existing_file($input_name, $maxwidth, $maxheight,
            $square = false, $x1 = 0, $y1 = 0, $x2 = 0, $y2 = 0, $upscale = false) {

    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated. Use elgg_save_resized_image()', '2.3');

    if (!is_readable($input_name)) {
        return false;
    }

    // we will write resized image to a temporary file and then delete it
    // need to add a valid image extension otherwise resizing fails
    $tmp_filename = tempnam(sys_get_temp_dir(), 'icon_resize');
    
    $params = [
        'w' => $maxwidth,
        'h' => $maxheight,
        'x1' => $x1,
        'y1' => $y1,
        'x2' => $x2,
        'y2' => $y2,
        'square' => $square,
        'upscale' => $upscale,
    ];

    $image_bytes = false;
    if (elgg_save_resized_image($input_name, $tmp_filename, $params)) {
        $image_bytes = file_get_contents($tmp_filename);
    }

    unlink($tmp_filename);

    return $image_bytes;
}

function get_image_resize_parameters($width, $height, array $params = []) {

    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated and will be removed from public API', '2.3');

    try {
        $params['w'] = elgg_extract('maxwidth', $params);
        $params['h'] = elgg_extract('maxheight', $params);
        unset($params['maxwidth']);
        unset($params['maxheight']);
        $params = _elgg_services()->imageService->normalizeResizeParameters($width, $height, $params);
        return [
            'newwidth' => $params['w'],
            'newheight' => $params['h'],
            'selectionwidth' => $params['x2'] - $params['x1'],
            'selectionheight' => $params['y2'] - $params['y1'],
            'xoffset' => $params['x1'],
            'yoffset' => $params['y1'],
        ];
    } catch (\LogicException $ex) {
        elgg_log($ex->getMessage(), 'ERROR');
        return false;
    }
}

function file_delete($guid) {
    $file = get_entity($guid);
    if (!$file || !$file->canEdit()) {
        return false;
    }

    $thumbnail = $file->thumbnail;
    $smallthumb = $file->smallthumb;
    $largethumb = $file->largethumb;
    if ($thumbnail) {
        $delfile = new \ElggFile();
        $delfile->owner_guid = $file->owner_guid;
        $delfile->setFilename($thumbnail);
        $delfile->delete();
    }
    if ($smallthumb) {
        $delfile = new \ElggFile();
        $delfile->owner_guid = $file->owner_guid;
        $delfile->setFilename($smallthumb);
        $delfile->delete();
    }
    if ($largethumb) {
        $delfile = new \ElggFile();
        $delfile->owner_guid = $file->owner_guid;
        $delfile->setFilename($largethumb);
        $delfile->delete();
    }

    return $file->delete();
}

function delete_directory($directory) {
    // sanity check: must be a directory
    if (!$handle = opendir($directory)) {
        return false;
    }

    // loop through all files
    while (($file = readdir($handle)) !== false) {
        if (in_array($file, array('.', '..'))) {
            continue;
        }

        $path = "$directory/$file";
        if (is_dir($path)) {
            // recurse down through directory
            if (!delete_directory($path)) {
                return false;
            }
        } else {
            // delete file
            unlink($path);
        }
    }

    // remove empty directory
    closedir($handle);
    return rmdir($directory);
}

function _elgg_clear_entity_files($entity) {
    $dir = new \Elgg\EntityDirLocator($entity->guid);
    $file_path = elgg_get_config('dataroot') . $dir;
    if (file_exists($file_path)) {
        delete_directory($file_path);
    }
}

$DEFAULT_FILE_STORE = null;

function get_default_filestore() {
    elgg_deprecated_notice(__FUNCTION__ . ' is deprecated.', '2.1');

    return $GLOBALS['DEFAULT_FILE_STORE'];
}

function set_default_filestore(\ElggFilestore $filestore) {
    elgg_deprecated_notice(__FUNCTION__ . ' is deprecated.', '2.1');

    $GLOBALS['DEFAULT_FILE_STORE'] = $filestore;
    return true;
}

function elgg_get_file_simple_type($mime_type) {
    $params = array('mime_type' => $mime_type);
    return elgg_trigger_plugin_hook('simple_type', 'file', $params, 'general');
}

function _elgg_filestore_boot() {
    global $CONFIG;

    // Now register a default filestore
    if (isset($CONFIG->dataroot)) {
        $GLOBALS['DEFAULT_FILE_STORE'] = new \ElggDiskFilestore($CONFIG->dataroot);
    }
}

function _elgg_filestore_init() {

    // Fix MIME type detection for Microsoft zipped formats
    elgg_register_plugin_hook_handler('mime_type', 'file', '_elgg_filestore_detect_mimetype');

    // Parse category of file from MIME type
    elgg_register_plugin_hook_handler('simple_type', 'file', '_elgg_filestore_parse_simpletype');

    // Unit testing
    elgg_register_plugin_hook_handler('unit_test', 'system', '_elgg_filestore_test');

    // Handler for serving embedded icons
    elgg_register_page_handler('serve-icon', '_elgg_filestore_serve_icon_handler');

    // Touch entity icons if entity access id has changed
    elgg_register_event_handler('update:after', 'object', '_elgg_filestore_touch_icons');
    elgg_register_event_handler('update:after', 'group', '_elgg_filestore_touch_icons');

    // Move entity icons if entity owner has changed
    elgg_register_event_handler('update:after', 'object', '_elgg_filestore_move_icons');
    elgg_register_event_handler('update:after', 'group', '_elgg_filestore_move_icons');
}

function _elgg_filestore_detect_mimetype($hook, $type, $mime_type, $params) {

    $original_filename = elgg_extract('original_filename', $params);
    $ext = pathinfo($original_filename, PATHINFO_EXTENSION);

    return (new \Elgg\Filesystem\MimeTypeDetector())->fixDetectionErrors($mime_type, $ext);
}

function _elgg_filestore_parse_simpletype($hook, $type, $simple_type, $params) {

    $mime_type = elgg_extract('mime_type', $params);

    switch ($mime_type) {
        case "application/msword":
        case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
        case "application/pdf":
            return "document";

        case "application/ogg":
            return "audio";
    }

    if (preg_match('~^(audio|image|video)/~', $mime_type, $m)) {
        return $m[1];
    }
    if (0 === strpos($mime_type, 'text/') || false !== strpos($mime_type, 'opendocument')) {
        return "document";
    }

    // unrecognized MIME
    return $simple_type;
}

function _elgg_filestore_test($hook, $type, $value) {
    global $CONFIG;
    $value[] = "{$CONFIG->path}engine/tests/ElggCoreFilestoreTest.php";
    return $value;
}

function elgg_get_download_url(\ElggFile $file, $use_cookie = true, $expires = '+2 hours') {
    $file_svc = new Elgg\FileService\File();
    $file_svc->setFile($file);
    $file_svc->setExpires($expires);
    $file_svc->setDisposition('attachment');
    $file_svc->bindSession($use_cookie);
    return $file_svc->getURL();
}

function elgg_get_inline_url(\ElggFile $file, $use_cookie = false, $expires = '') {
    $file_svc = new Elgg\FileService\File();
    $file_svc->setFile($file);
    if ($expires) {
        $file_svc->setExpires($expires);
    }
    $file_svc->setDisposition('inline');
    $file_svc->bindSession($use_cookie);
    return $file_svc->getURL();
}

function elgg_get_embed_url(\ElggEntity $entity, $size) {
    return elgg_normalize_url("serve-icon/$entity->guid/$size");
}

function _elgg_filestore_serve_icon_handler() {
    $response = _elgg_services()->iconService->handleServeIconRequest();
    $response->send();
    exit;
}

function _elgg_filestore_touch_icons($event, $type, $entity) {
    $original_attributes = $entity->getOriginalAttributes();
    if (!array_key_exists('access_id', $original_attributes)) {
        return;
    }
    if ($entity instanceof \ElggFile) {
        // we touch the file to invalidate any previously generated download URLs
        $entity->setModifiedTime();
    }
    $sizes = array_keys(elgg_get_icon_sizes($entity->getType(), $entity->getSubtype()));
    foreach ($sizes as $size) {
        $icon = $entity->getIcon($size);
        if ($icon->exists()) {
            $icon->setModifiedTime();
        }
    }
}

function _elgg_filestore_move_icons($event, $type, $entity) {

    $original_attributes = $entity->getOriginalAttributes();
    if (empty($original_attributes['owner_guid'])) {
        return;
    }

    $previous_owner_guid = $original_attributes['owner_guid'];
    $new_owner_guid = $entity->owner_guid;

    $sizes = elgg_get_icon_sizes($entity->getType(), $entity->getSubtype());

    foreach ($sizes as $size => $opts) {
        $new_icon = $entity->getIcon($size);
        if ($new_icon->owner_guid == $entity->guid) {
            // we do not need to update icons that are owned by the entity itself
            continue;
        }

        if ($new_icon->owner_guid != $new_owner_guid) {
            // a plugin implements some custom logic
            continue;
        }

        $old_icon = new \ElggIcon();
        $old_icon->owner_guid = $previous_owner_guid;
        $old_icon->setFilename($new_icon->getFilename());
        if (!$old_icon->exists()) {
            // there is no icon to move
            continue;
        }

        if ($new_icon->exists()) {
            // there is already a new icon
            // just removing the old one
            $old_icon->delete();
            elgg_log("Entity $entity->guid has been transferred to a new owner but an icon was "
                . "left behind under {$old_icon->getFilenameOnFilestore()}. "
                . "Old icon has been deleted", 'NOTICE');
            continue;
        }

        $old_icon->transfer($new_icon->owner_guid, $new_icon->getFilename());
        elgg_log("Entity $entity->guid has been transferred to a new owner. "
        . "Icon was moved from {$old_icon->getFilenameOnFilestore()} to {$new_icon->getFilenameOnFilestore()}.", 'NOTICE');
    }
}

function elgg_get_uploaded_files($input_name) {
    return _elgg_services()->uploads->getUploadedFiles($input_name);
}

return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
    $events->registerHandler('boot', 'system', '_elgg_filestore_boot', 100);
    $events->registerHandler('init', 'system', '_elgg_filestore_init', 100);
};