ImageEditor::__construct() - Code Metrics - Inspection of "dependency update" - mambax7/xoopseditors - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6ebac0...a0be99 )

by Michael
created 2022-06-12 05:36 UTC
ImageEditor::__construct() A

↳ Parent: ImageEditor
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	4
rs	10
<?php
/**
 * Image Editor. Editing tools, crop, rotate, scale and save.
 * @author  $Author:ray $
 * @version $Id:ImageEditor.php 938 2008-01-22 20:13:47Z ray $
 * @package ImageManager
 */

require_once('../ImageManager/Classes/Transform.php');

/**
 * Handles the basic image editing capbabilities.
 * @author     $Author:ray $
 * @version    $Id:ImageEditor.php 938 2008-01-22 20:13:47Z ray $
 * @package    ImageManager
 * @subpackage Editor
 */
class ImageEditor
{
    /**
     * ImageManager instance.
     */
    public $manager;

    /**
     * user based on IP address
     */
    public $_uid;

    /**
     * tmp file storage time.
     */
    public $lapse_time = 900; //15 mins

    public $filesaved = 0;

    /**
     * Create a new ImageEditor instance. Editing requires a
     * tmp file, which is saved in the current directory where the
     * image is edited. The tmp file is assigned by md5 hash of the
     * user IP address. This hashed is used as an ID for cleaning up
     * the tmp files. In addition, any tmp files older than the
     * the specified period will be deleted.
     * @param ImageManager $manager the image manager, we need this
     *                              for some file and path handling functions.
     */
    public function __construct($manager)
    {
        $this->manager = $manager;
        $this->_uid    = md5($_SERVER['REMOTE_ADDR']);
    }

    /**
     * Did we save a file?
     * @return int 1 if the file was saved sucessfully,
     * 0 no save operation, -1 file save error.
     */
    public function isFileSaved()
    {
        Return $this->filesaved;
    }

    /**
     * Process the image, if not action, just display the image.
     * @return array with image information, empty array if not an image.
     * <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
     * 'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
     */
    public function processImage()
    {
        if (isset($_GET['img'])) {
            $relative = rawurldecode($_GET['img']);
        } else {
            Return [];
        }

        //$relative = '/Series2004NoteFront.jpg';

        $imgURL   = $this->manager->getFileURL($relative);
        $fullpath = $this->manager->getFullPath($relative);

        $imgInfo = @getImageSize($fullpath);
        if (!is_array($imgInfo)) {
            Return [];
        }

        $action = $this->getAction();

        if (!is_null($action)) {

            $image = $this->processAction($action, $relative, $fullpath);
        } else {
            $image['src']        = $imgURL;

            $image['dimensions'] = $imgInfo[3];
            $image['file']       = $relative;
            $image['fullpath']   = $fullpath;
            $image['filesize']   = @filesize($fullpath);
        }

        Return $image;
    }

    /**
     * Process the actions, crop, scale(resize), rotate, flip, and save.
     * When ever an action is performed, the result is save into a
     * temporary image file, see createUnique on the filename specs.
     * It does not return the saved file, alway returning the tmp file.
     * @param string $action   , should be 'crop', 'scale', 'rotate','flip', or 'save'
     * @param string $relative the relative image filename
     * @param string $fullpath the fullpath to the image file
     * @return array with image information
     *                         <code>array('src'=>'url of the image', 'dimensions'=>'width="xx" height="yy"',
     *                         'file'=>'image file, relative', 'fullpath'=>'full path to the image');</code>
     */
    public function processAction($action, $relative, $fullpath)
    {
        $params = '';

        if (isset($_GET['params'])) {
            $params = $_GET['params'];
        }

        $values   = explode(',', $params);
        $saveFile = $this->getSaveFileName($values[0]);

        $img = Image_Transform::factory(IMAGE_CLASS);
        $img = Image_Transform::factory(IMAGE_CLASS);
        $img->load($fullpath);

        if (is_callable([$img, 'paletteToTrueColorWithTransparency']) && !imageistruecolor($img->imageHandle)) {
            $img->paletteToTrueColorWithTransparency();
        }
        switch ($action) {
            case 'crop':
                $img->crop(
                    intval($values[0]),
                    intval($values[1]),
                    intval($values[2]),
                    intval($values[3])
                );
                break;
            case 'scale':
                $img->resize(intval($values[0]), intval($values[1]));
                break;
            case 'rotate':
                $img->rotate(floatval($values[0]));
                break;
            case 'flip':
                if ('hoz' == $values[0]) {
                    $img->flip(true);
                } elseif ('ver' == $values[0]) {
                    $img->flip(false);
                }
                break;
            case 'save':
                if (!is_null($saveFile)) {
                    $quality = intval($values[1]);
                    if ($quality < 0) {
                        $quality = 85;
                    }
                    $newSaveFile = $this->makeRelative($relative, $saveFile);
                    $newSaveFile = $this->getUniqueFilename($newSaveFile);

                    //get unique filename just returns the filename, so
                    //we need to make the relative path once more.
                    $newSaveFile       = $this->makeRelative($relative, $newSaveFile);
                    $image['saveFile'] = $newSaveFile;

                    $newSaveFullpath   = $this->manager->getFullPath($newSaveFile);
                    if ('gif' == $values[0] && is_callable([$img, 'preserveTransparencyForPalette'])) {
                        $img->preserveTransparencyForPalette();
                    }
                    $img->save($newSaveFullpath, $values[0], $quality);
                    if (is_file($newSaveFullpath)) {
                        $this->filesaved = 1;
                    } else {
                        $this->filesaved = -1;
                    }
                }
                break;
            case 'preview':
                $quality = intval($values[1]);


                $image['file']     = $relative;
                $image['fullpath'] = $fullpath;

                //create the tmp image file
                $filename    = $this->createUnique($fullpath);
                $newRelative = $this->makeRelative($relative, $filename);
                $newFullpath = $this->manager->getFullPath($newRelative);
                $newURL      = $this->manager->getFileURL($newRelative);

                if ('gif' == $values[0] && is_callable([$img, 'preserveTransparencyForPalette'])) {
                    $img->preserveTransparencyForPalette();
                }
                $img->save($newFullpath, $values[0]);
                $img->free();

                //get the image information
                $imgInfo = @getimagesize($newFullpath);

                $image['src']        = $newURL;
                $image['width']      = $imgInfo[0];
                $image['height']     = $imgInfo[1];
                $image['dimensions'] = $imgInfo[3];
                $image['file']       = $relative;
                $image['fullpath']   = $fullpath;
                $image['filesize']   = @filesize($newFullpath);

                Return $image;

                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }

        //create the tmp image file
        $filename    = $this->createUnique($fullpath);
        $newRelative = $this->makeRelative($relative, $filename);
        $newFullpath = $this->manager->getFullPath($newRelative);
        $newURL      = $this->manager->getFileURL($newRelative);

        //save the file.
        $img->save($newFullpath, 'png');
        $img->free();

        //get the image information
        $imgInfo = @getimagesize($newFullpath);

        $image['src']        = $newURL;
        $image['width']      = $imgInfo[0];
        $image['height']     = $imgInfo[1];
        $image['dimensions'] = $imgInfo[3];
        $image['file']       = $newRelative;
        $image['fullpath']   = $newFullpath;
        $image['filesize']   = @filesize($newFullpath);
        $image['type']       = image_type_to_mime_type($imgInfo[2]);

        Return $image;
    }

    /**
     * Get the file name base on the save name
     * and the save type.
     * @param string $type image type, 'jpeg', 'png', or 'gif'
     * @return string the filename according to save type
     */
    public function getSaveFileName($type)
    {
        if (!isset($_GET['file'])) {
            Return null;
        }

        $filename = Files::escape(rawurldecode($_GET['file']));
        $filename = Files::escape(rawurldecode($_GET['file']));
        $index    = strrpos($filename, '.');
        $base     = substr($filename, 0, $index);
        $ext      = strtolower(substr($filename, $index + 1, strlen($filename)));

        if ('jpeg' == $type && !('jpeg' == $ext || 'jpg' == $ext)) {
            Return $base . '.jpeg';
        }
        if ('png' == $type && 'png' != $ext) {
            Return $base . '.png';
        }
        if ('gif' == $type && 'gif' != $ext) {
            Return $base . '.gif';
        }

        // Ensure type is in acceptable image types
        $valid_extensions = $this->manager->config['allowed_image_extensions'];
        if (!in_array($ext, $valid_extensions)) {
            return $base . '.' . strtolower($type ? $type : 'jpg');
        }

        Return $filename;
    }

    /**
     * Get the default save file name, used by editor.php.
     * @return string a suggestive filename, this should be unique
     */
    public function getDefaultSaveFile()
    {
        if (isset($_GET['img'])) {
            $relative = rawurldecode($_GET['img']);
        } else {
            Return null;
        }

        Return $this->getUniqueFilename($relative);
    }

    /**
     * Get a unique filename. If the file exists, the filename
     * base is appended with an increasing integer.
     * @param string $relative the relative filename to the base_dir
     * @return string a unique filename in the current path
     */
    public function getUniqueFilename($relative)
    {
        $fullpath = $this->manager->getFullPath($relative);

        $pathinfo = pathinfo($fullpath);

        $path = Files::fixPath($pathinfo['dirname']);
        $path = Files::fixPath($pathinfo['dirname']);
        $file = Files::escape($pathinfo['basename']);
        $file = Files::escape($pathinfo['basename']);

        $filename = $file;

        $dotIndex = strrpos($file, '.');
        $ext      = '';

        if (is_int($dotIndex)) {

            $ext  = substr($file, $dotIndex);
            $base = substr($file, 0, $dotIndex);
        }

        $counter = 0;
        while (is_file($path . $filename)) {
            $counter++;
            $filename = $base . '_' . $counter . $ext;

        }

        Return $filename;
    }

    /**
     * Specifiy the original relative path, a new filename
     * and return the new filename with relative path.
     * i.e. $pathA (-filename) + $file
     * @param string $pathA the relative file
     * @param string $file  the new filename
     * @return string relative path with the new filename
     */
    public function makeRelative($pathA, $file)
    {
        $index = strrpos($pathA, '/');
        if (!is_int($index)) {

            Return $file;
        }

        $path = substr($pathA, 0, $index);
        Return Files::fixPath($path) . $file;
        Return Files::/** @scrutinizer ignore-call */ fixPath($path) . $file;
    }

    /**
     * Get the action GET parameter
     * @return string action parameter
     */
    public function getAction()
    {
        $action = null;
        if (isset($_GET['action'])) {
            $action = $_GET['action'];
        }
        Return $action;
    }

    /**
     * Generate a unique string based on md5(microtime()).
     * Well not so uniqe, as it is limited to 6 characters
     * @return string unique string.
     */
    public function uniqueStr()
    {
        return substr(md5(microtime()), 0, 6);
    }

    /**
     * Create unique tmp image file name.
     * The filename is based on the tmp file prefix
     * specified in config.inc.php plus
     * the UID (basically a md5 of the remote IP)
     * and some random 6 character string.
     * This function also calls to clean up the tmp files.
     * @param string $file the fullpath to a file
     * @return string a unique filename for that path
     *                     NOTE: it only returns the filename, path no included.
     */
    public function createUnique($file)
    {
        $pathinfo = pathinfo($file);
        $path     = Files::fixPath($pathinfo['dirname']);
        $path     = Files::fixPath($pathinfo['dirname']);
        $imgType  = $this->getImageType($file);

        $unique_str = $this->manager->getTmpPrefix() . $this->_uid . '_' . $this->uniqueStr() . '.' . $imgType;

        //make sure the the unique temp file does not exists
        while (file_exists($path . $unique_str)) {
            $unique_str = $this->manager->getTmpPrefix() . $this->_uid . '_' . $this->uniqueStr() . '.' . $imgType;
        }

        $this->cleanUp($path, $pathinfo['basename']);

        Return $unique_str;
    }

    /**
     * Delete any tmp image files.
     * @param string $path the full path
     *                     where the clean should take place.
     */
    public function cleanUp($path, $file)
    {
        $path = Files::fixPath($path);
        $path = Files::fixPath($path);

        if (!is_dir($path)) {
            Return false;
        }

        $d = @dir($path);

        $tmp    = $this->manager->getTmpPrefix();
        $tmpLen = strlen($tmp);

        $prefix = $tmp . $this->_uid;
        $len    = strlen($prefix);

        while (false !== ($entry = $d->read())) {
            //echo $entry."<br>";
            if (is_file($path . $entry) && $this->manager->isTmpFile($entry)) {
                if (substr($entry, 0, $len) == $prefix && $entry != $file) {
                    Files::delFile($path . $entry);
                           delFile($path . $entry);
                } elseif (substr($entry, 0, $tmpLen) == $tmp && $entry != $file) {
                    if (filemtime($path . $entry) + $this->lapse_time < time()) {
                        Files::delFile($path . $entry);
                    }
                }
            }
        }
        $d->close();
    }

    /**
     * Get the image type base on an image file.
     * @param string $file the full path to the image file.
     * @return string of either 'gif', 'jpeg', 'png' or 'bmp'
     *                     otherwise it will return null.
     */
    public function getImageType($file)
    {
        $imageInfo = @getImageSize($file);

        if (!is_array($imageInfo)) {
            Return null;
        }

        switch ($imageInfo[2]) {
            case 1:
                Return 'gif';
            case 2:
                Return 'jpeg';
            case 3:
                Return 'png';
            case 6:
                Return 'bmp';
        }

        Return null;
    }

    /**
     * Check if the specified image can be edit by GD
     * mainly to check that GD can read and save GIFs
     * @return int 0 if it is not a GIF file, 1 is GIF is editable, -1 if not editable.
     */
    public function isGDEditable()
    {
        if (isset($_GET['img'])) {
            $relative = rawurldecode($_GET['img']);
        } else {
            Return 0;
        }
        if (IMAGE_CLASS != 'GD') {

            Return 0;
        }

        $fullpath = $this->manager->getFullPath($relative);

        $type = $this->getImageType($fullpath);
        if ('gif' != $type) {
            Return 0;
        }

        if (function_exists('ImageCreateFrom' . $type)
            && function_exists('image' . $type)) {
            Return 1;
        } else {
            Return -1;
        }
    }

    /**
     * Check if GIF can be edit by GD.
     * @return int 0 if it is not using the GD library, 1 is GIF is editable, -1 if not editable.
     */
    public function isGDGIFAble()
    {
        if (IMAGE_CLASS != 'GD') {

            Return 0;
        }

        if (function_exists('ImageCreateFromGif')
            && function_exists('imagegif')) {
            Return 1;
        } else {
            Return -1;
        }
    }
}



mambax7 / xoopseditors

Push — master ( 6ebac0...a0be99 )

ImageEditor::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
