EntityIconService.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Database\EntityTable;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Exceptions\UnexpectedValueException;
use Elgg\Exceptions\InvalidParameterException;
use Elgg\Exceptions\LogicException;
use Elgg\Filesystem\MimeTypeService;
use Elgg\Http\Request as HttpRequest;
use Elgg\Traits\Loggable;
use Elgg\Traits\TimeUsing;

class EntityIconService {

    use Loggable;
    use TimeUsing;

    private $config;

    private $events;

    private $entities;

    private $uploads;

    private $images;
    
    protected $mimetype;
    
    protected $request;

    public function __construct(
        Config $config,
        EventsService $events,
        EntityTable $entities,
        UploadService $uploads,
        ImageService $images,
        MimeTypeService $mimetype,
        HttpRequest $request
    ) {
        $this->config = $config;
        $this->events = $events;
        $this->entities = $entities;
        $this->uploads = $uploads;
        $this->images = $images;
        $this->mimetype = $mimetype;
        $this->request = $request;
    }

    public function saveIconFromUploadedFile(\ElggEntity $entity, $input_name, $type = 'icon', array $coords = []) {
        $input = $this->uploads->getFile($input_name);
        if (empty($input)) {
            return false;
        }
                
        // auto detect cropping coordinates
        if (empty($coords)) {
            $auto_coords = $this->detectCroppingCoordinates($input_name);
            if (!empty($auto_coords)) {
                $coords = $auto_coords;
            }
        }

        $tmp = new \ElggTempFile();
        $tmp->setFilename(uniqid() . $input->getClientOriginalName());
        $tmp->open('write');
        $tmp->close();
        
        copy($input->getPathname(), $tmp->getFilenameOnFilestore());

        $tmp->mimetype = $this->mimetype->getMimeType($tmp->getFilenameOnFilestore());
        $tmp->simpletype = $this->mimetype->getSimpleType($tmp->mimetype);

        $result = $this->saveIcon($entity, $tmp, $type, $coords);

        $tmp->delete();

        return $result;
    }

    public function saveIconFromLocalFile(\ElggEntity $entity, $filename, $type = 'icon', array $coords = []) {
        if (!file_exists($filename) || !is_readable($filename)) {
            throw new InvalidArgumentException(__METHOD__ . " expects a readable local file. {$filename} is not readable");
        }
                
        $tmp = new \ElggTempFile();
        $tmp->setFilename(uniqid() . basename($filename));
        $tmp->open('write');
        $tmp->close();
        
        copy($filename, $tmp->getFilenameOnFilestore());

        $tmp->mimetype = $this->mimetype->getMimeType($tmp->getFilenameOnFilestore());
        $tmp->simpletype = $this->mimetype->getSimpleType($tmp->mimetype);

        $result = $this->saveIcon($entity, $tmp, $type, $coords);

        $tmp->delete();

        return $result;
    }

    public function saveIconFromElggFile(\ElggEntity $entity, \ElggFile $file, $type = 'icon', array $coords = []) {
        if (!$file->exists()) {
            throw new InvalidArgumentException(__METHOD__ . ' expects an instance of ElggFile with an existing file on filestore');
        }
        
        $tmp = new \ElggTempFile();
        $tmp->setFilename(uniqid() . basename($file->getFilenameOnFilestore()));
        $tmp->open('write');
        $tmp->close();
        
        copy($file->getFilenameOnFilestore(), $tmp->getFilenameOnFilestore());

        $tmp->mimetype = $this->mimetype->getMimeType($tmp->getFilenameOnFilestore(), $file->getMimeType() ?: '');
        $tmp->simpletype = $this->mimetype->getSimpleType($tmp->mimetype);

        $result = $this->saveIcon($entity, $tmp, $type, $coords);

        $tmp->delete();

        return $result;
    }

    public function saveIcon(\ElggEntity $entity, \ElggFile $file, $type = 'icon', array $coords = []) {

        $type = (string) $type;
        if (!strlen($type)) {
            $this->getLogger()->error('Icon type passed to ' . __METHOD__ . ' can not be empty');
            return false;
        }
        
        $entity_type = $entity->getType();
        
        $file = $this->events->triggerResults("entity:{$type}:prepare", $entity_type, [
            'entity' => $entity,
            'file' => $file,
        ], $file);
        
        if (!$file instanceof \ElggFile || !$file->exists() || $file->getSimpleType() !== 'image') {
            $this->getLogger()->error('Source file passed to ' . __METHOD__ . ' can not be resolved to a valid image');
            return false;
        }
        
        $this->prepareIcon($file->getFilenameOnFilestore());
        
        $x1 = (int) elgg_extract('x1', $coords);
        $y1 = (int) elgg_extract('y1', $coords);
        $x2 = (int) elgg_extract('x2', $coords);
        $y2 = (int) elgg_extract('y2', $coords);
        
        $created = $this->events->triggerResults("entity:{$type}:save", $entity_type, [
            'entity' => $entity,
            'file' => $file,
            'x1' => $x1,
            'y1' => $y1,
            'x2' => $x2,
            'y2' => $y2,
        ], false);

        // did someone else handle saving the icon?
        if ($created !== true) {
            // remove existing icons
            $this->deleteIcon($entity, $type, true);
            
            // save master image
            $store = $this->generateIcon($entity, $file, $type, $coords, 'master');
            
            if (!$store) {
                $this->deleteIcon($entity, $type);
                return false;
            }
            
            // validate cropping coords to prevent out-of-bounds issues
            try {
                $sizes = $this->getSizes($entity->getType(), $entity->getSubtype(), $type);
                $coords = array_merge($sizes['master'], $coords);
                
                $icon = $this->getIcon($entity, 'master', $type, false);
                
                $this->images->normalizeResizeParameters($icon->getFilenameOnFilestore(), $coords);
            } catch (LogicException $e) {
                // cropping coords are wrong, reset to 0
                $x1 = 0;
                $x2 = 0;
                $y1 = 0;
                $y2 = 0;
            }
        }

        if ($type == 'icon') {
            $entity->icontime = time();
            if ($x1 || $y1 || $x2 || $y2) {
                $entity->x1 = $x1;
                $entity->y1 = $y1;
                $entity->x2 = $x2;
                $entity->y2 = $y2;
            }
        } else {
            if ($x1 || $y1 || $x2 || $y2) {
                $entity->{"{$type}_coords"} = serialize([
                    'x1' => $x1,
                    'y1' => $y1,
                    'x2' => $x2,
                    'y2' => $y2,
                ]);
            }
        }
        
        $this->events->triggerResults("entity:{$type}:saved", $entity->getType(), [
            'entity' => $entity,
            'x1' => $x1,
            'y1' => $y1,
            'x2' => $x2,
            'y2' => $y2,
        ]);
        
        return true;
    }
    
    protected function prepareIcon($filename) {
        
        // fix orientation
        $temp_file = new \ElggTempFile();
        $temp_file->setFilename(uniqid() . basename($filename));
        
        copy($filename, $temp_file->getFilenameOnFilestore());
        
        $rotated = $this->images->fixOrientation($temp_file->getFilenameOnFilestore());

        if ($rotated) {
            copy($temp_file->getFilenameOnFilestore(), $filename);
        }
        
        $temp_file->delete();
    }
    
    protected function generateIcon(\ElggEntity $entity, \ElggFile $file, $type = 'icon', $coords = [], $icon_size = '') {
        
        if (!$file->exists()) {
            $this->getLogger()->error('Trying to generate an icon from a non-existing file');
            return false;
        }
        
        $x1 = (int) elgg_extract('x1', $coords);
        $y1 = (int) elgg_extract('y1', $coords);
        $x2 = (int) elgg_extract('x2', $coords);
        $y2 = (int) elgg_extract('y2', $coords);
        
        $sizes = $this->getSizes($entity->getType(), $entity->getSubtype(), $type);
        
        if (!empty($icon_size) && !isset($sizes[$icon_size])) {
            $this->getLogger()->warning("The provided icon size '{$icon_size}' doesn't exist for icon type '{$type}'");
            return false;
        }
        
        foreach ($sizes as $size => $opts) {
            if (!empty($icon_size) && ($icon_size !== $size)) {
                // only generate the given icon size
                continue;
            }
            
            // check if the icon config allows cropping
            if (!(bool) elgg_extract('crop', $opts, true)) {
                $coords = [
                    'x1' => 0,
                    'y1' => 0,
                    'x2' => 0,
                    'y2' => 0,
                ];
            }

            $icon = $this->getIcon($entity, $size, $type, false);

            // We need to make sure that file path is readable by
            // Imagine\Image\ImagineInterface::save(), as it fails to
            // build the directory structure on owner's filestore otherwise
            $icon->open('write');
            $icon->close();
            
            // Save the image without resizing or cropping if the
            // image size value is an empty array
            if (is_array($opts) && empty($opts)) {
                copy($file->getFilenameOnFilestore(), $icon->getFilenameOnFilestore());
                continue;
            }

            $source = $file->getFilenameOnFilestore();
            $destination = $icon->getFilenameOnFilestore();

            $resize_params = array_merge($opts, $coords);

            $image_service = _elgg_services()->imageService;
            $image_service->setLogger($this->getLogger());

            if (!_elgg_services()->imageService->resize($source, $destination, $resize_params)) {
                $this->getLogger()->error("Failed to create {$size} icon from
                    {$file->getFilenameOnFilestore()} with coords [{$x1}, {$y1}],[{$x2}, {$y2}]");
                return false;
            }
        }

        return true;
    }

    public function getIcon(\ElggEntity $entity, $size, $type = 'icon', $generate = true) {

        $size = elgg_strtolower($size);

        $params = [
            'entity' => $entity,
            'size' => $size,
            'type' => $type,
        ];

        $entity_type = $entity->getType();

        $default_icon = new \ElggIcon();
        $default_icon->owner_guid = $entity->guid;
        $default_icon->setFilename("icons/{$type}/{$size}.jpg");

        $icon = $this->events->triggerResults("entity:{$type}:file", $entity_type, $params, $default_icon);
        if (!$icon instanceof \ElggIcon) {
            throw new UnexpectedValueException("'entity:{$type}:file', {$entity_type} event must return an instance of \ElggIcon");
        }
        
        if ($size !== 'master' && $this->hasWebPSupport()) {
            if (pathinfo($icon->getFilename(), PATHINFO_EXTENSION) === 'jpg') {
                $icon->setFilename(substr($icon->getFilename(), 0, -3) . 'webp');
            }
        }
        
        if ($icon->exists() || !$generate) {
            return $icon;
        }
        
        if ($size === 'master') {
            // don't try to generate for master
            return $icon;
        }
        
        // try to generate icon based on master size
        $master_icon = $this->getIcon($entity, 'master', $type, false);
        if (!$master_icon->exists()) {
            return $icon;
        }
        
        if ($type === 'icon') {
            $coords = [
                'x1' => $entity->x1,
                'y1' => $entity->y1,
                'x2' => $entity->x2,
                'y2' => $entity->y2,
            ];
        } else {
            $coords = $entity->{"{$type}_coords"};
            $coords = empty($coords) ? [] : unserialize($coords);
        }
        
        $this->generateIcon($entity, $master_icon, $type, $coords, $size);
        
        return $icon;
    }

    public function deleteIcon(\ElggEntity $entity, $type = 'icon', $retain_master = false) {
        $delete = $this->events->triggerResults("entity:{$type}:delete", $entity->getType(), [
            'entity' => $entity,
        ], true);

        if ($delete === false) {
            return false;
        }
        
        $result = true;
        $supported_extensions = [
            'jpg',
        ];
        if ($this->images->hasWebPSupport()) {
            $supported_extensions[] = 'webp';
        }

        $sizes = array_keys($this->getSizes($entity->getType(), $entity->getSubtype(), $type));
        foreach ($sizes as $size) {
            if ($size === 'master' && $retain_master) {
                continue;
            }
            
            $icon = $this->getIcon($entity, $size, $type, false);
            $result &= $icon->delete();
            
            // make sure we remove all supported images (jpg and webp)
            $current_extension = pathinfo($icon->getFilename(), PATHINFO_EXTENSION);
            $extensions = $supported_extensions;
            foreach ($extensions as $extension) {
                if ($current_extension === $extension) {
                    // already removed
                    continue;
                }
                
                // replace the extension
                $parts = explode('.', $icon->getFilename());
                array_pop($parts);
                $parts[] = $extension;
                
                // set new filename and remove the file
                $icon->setFilename(implode('.', $parts));
                $result &= $icon->delete();
            }
        }

        if ($type == 'icon') {
            unset($entity->icontime);
            unset($entity->x1);
            unset($entity->y1);
            unset($entity->x2);
            unset($entity->y2);
        } else {
            unset($entity->{"{$type}_coords"});
        }
        
        return $result;
    }

    public function getIconURL(\ElggEntity $entity, string|array $params = []): string {
        if (is_array($params)) {
            $size = elgg_extract('size', $params, 'medium');
        } else {
            $size = is_string($params) ? $params : 'medium';
            $params = [];
        }

        $size = elgg_strtolower($size);

        $params['entity'] = $entity;
        $params['size'] = $size;

        $type = elgg_extract('type', $params, 'icon', false);
        $entity_type = $entity->getType();

        $url = $this->events->triggerResults("entity:{$type}:url", $entity_type, $params, null);
        if (!isset($url)) {
            if ($this->hasIcon($entity, $size, $type)) {
                $icon = $this->getIcon($entity, $size, $type);
                $default_use_cookie = (bool) elgg_get_config('session_bound_entity_icons');
                $url = $icon->getInlineURL((bool) elgg_extract('use_cookie', $params, $default_use_cookie));
            } else {
                $url = $this->getFallbackIconUrl($entity, $params);
            }
        }

        if (!empty($url)) {
            return elgg_normalize_url($url);
        }
        
        return '';
    }

    public function getFallbackIconUrl(\ElggEntity $entity, array $params = []) {
        $type = elgg_extract('type', $params, 'icon', false);
        $size = elgg_extract('size', $params, 'medium', false);
        
        $entity_type = $entity->getType();
        $entity_subtype = $entity->getSubtype();

        $exts = ['svg', 'gif', 'png', 'jpg'];

        foreach ($exts as $ext) {
            foreach ([$entity_subtype, 'default'] as $subtype) {
                if ($ext == 'svg' && elgg_view_exists("{$type}/{$entity_type}/{$subtype}.svg", 'default')) {
                    return elgg_get_simplecache_url("{$type}/{$entity_type}/{$subtype}.svg");
                }
                
                if (elgg_view_exists("{$type}/{$entity_type}/{$subtype}/{$size}.{$ext}", 'default')) {
                    return elgg_get_simplecache_url("{$type}/{$entity_type}/{$subtype}/{$size}.{$ext}");
                }
            }
        }

        if (elgg_view_exists("{$type}/default/{$size}.png", 'default')) {
            return elgg_get_simplecache_url("{$type}/default/{$size}.png");
        }
    }

    public function getIconLastChange(\ElggEntity $entity, $size, $type = 'icon') {
        $icon = $this->getIcon($entity, $size, $type);
        if ($icon->exists()) {
            return $icon->getModifiedTime();
        }
    }

    public function hasIcon(\ElggEntity $entity, $size, $type = 'icon') {
        $icon = $this->getIcon($entity, $size, $type);
        return $icon->exists() && $icon->getSize() > 0;
    }

    public function getSizes(string $entity_type = null, string $entity_subtype = null, $type = 'icon'): array {
        $sizes = [];
        $type = $type ?: 'icon';
        if ($type == 'icon') {
            $sizes = $this->config->icon_sizes;
        }
        
        $params = [
            'type' => $type,
            'entity_type' => $entity_type,
            'entity_subtype' => $entity_subtype,
        ];
        if ($entity_type) {
            $sizes = $this->events->triggerResults("entity:{$type}:sizes", $entity_type, $params, $sizes);
        }

        if (!is_array($sizes)) {
            $msg = "The icon size configuration for image type '{$type}'";
            $msg .= ' must be an associative array of image size names and their properties';
            throw new InvalidArgumentException($msg);
        }

        // lazy generation of icons requires a 'master' size
        // this ensures a default config for 'master' size
        $sizes['master'] = elgg_extract('master', $sizes, [
            'w' => 10240,
            'h' => 10240,
            'square' => false,
            'upscale' => false,
            'crop' => false,
        ]);
        
        if (!isset($sizes['master']['crop'])) {
            $sizes['master']['crop'] = false;
        }
        
        return $sizes;
    }
    
    protected function detectCroppingCoordinates(string $input_name) {
        
        $auto_coords = [
            'x1' => get_input("{$input_name}_x1", get_input('x1')), // x1 is BC fallback
            'x2' => get_input("{$input_name}_x2", get_input('x2')), // x2 is BC fallback
            'y1' => get_input("{$input_name}_y1", get_input('y1')), // y1 is BC fallback
            'y2' => get_input("{$input_name}_y2", get_input('y2')), // y2 is BC fallback
        ];
        
        $auto_coords = array_filter($auto_coords, function($value) {
            return !elgg_is_empty($value) && is_numeric($value) && (int) $value >= 0;
        });
        
        if (count($auto_coords) !== 4) {
            return false;
        }
        
        // make ints
        array_walk($auto_coords, function (&$value) {
            $value = (int) $value;
        });
        
        // make sure coords make sense x2 > x1 && y2 > y1
        if ($auto_coords['x2'] <= $auto_coords['x1'] || $auto_coords['y2'] <= $auto_coords['y1']) {
            return false;
        }
        
        return $auto_coords;
    }

    protected function hasWebPSupport(): bool {
        return in_array('image/webp', $this->request->getAcceptableContentTypes()) && $this->images->hasWebPSupport();
    }
}