AvatarEditAction.class.php

<?php
 * @package user
 * @author  Kazuhisa Minato aka minahito, Core developer
 * @version $Id: AvatarEditAction.class.php,v 1.3 2007/08/23 13:04:21 minahito Exp $
 */
 
if (!defined('XOOPS_ROOT_PATH')) {
    exit();
}
 
require_once XOOPS_ROOT_PATH . '/core/XCube_PageNavigator.class.php';
 
require_once XOOPS_MODULE_PATH . '/user/class/AbstractEditAction.class.php';
require_once XOOPS_MODULE_PATH . '/user/forms/AvatarEditForm.class.php';
require_once XOOPS_MODULE_PATH . '/user/forms/AvatarSelectForm.class.php';
require_once XOOPS_MODULE_PATH . '/user/forms/AvatarFilterForm.class.php';
 
/***
 * @internal
 * This action handles the uploaded avatar image file.
 *
 * Users who are allowed to upload, can upload custom avatars and select system
 * avatars. So this action has to implement both of uploading and selecting.
 * In the case of GET request, this action shows two forms to changing a avatar
 * for specified user. One of form shows upload-form. Anther form shows the list
 * of system avatars and the page navigator of the list.
 *
 * @see User_AvatarEditForm
 * @see User_AvatarSelectForm
 */
class User_AvatarEditAction extends User_AbstractEditAction
{
    /***
     * @var int
     */
    public $mAvatarWidth = 0;
 
    /***
     * @var int
     */
    public $mAvatarHeight = 0;
 
    /***
     * @var int
     */
    public $mAvatarMaxfilesize = 0;
 
    /***
     * @var int
     */
    public $_mMinPost = 0;
 
    /***
     * @var bool
     */
    public $_mAllowUpload = false;
 
    /***
     * @var User_AvatarFilterForm
     */
    public $mFilter;
 
    /***
     * Preset avatar object collection.
     */
    public $mSystemAvatars = [];
 
    /***
     * Other action form for AvatarSelect.
     * @var User_AvatarSelectForm
     */
    public $mAvatarSelectForm = null;
 
    /***
     * Fetch conditions from $moduleConfig and set these to member properties.
     * And, by the member property mConfig of the base class, any member
     * functions of this class can access $moduleConfig.
     *
     * @param $controller
     * @param $xoopsUser
     * @param $moduleConfig
     * @todo The limit may be not completed, yet.
     */
    public function prepare(&$controller, &$xoopsUser, $moduleConfig)
    {
        $this->mAvatarWidth = $moduleConfig['avatar_width'];
        $this->mAvatarHeight = $moduleConfig['avatar_height'];
        $this->mAvatarMaxfilesize = $moduleConfig['avatar_maxsize'];
 
        $this->_mMinPost = $moduleConfig['avatar_minposts'];
        $this->_mAllowUpload = $moduleConfig['avatar_allow_upload'];
 
        parent::prepare($controller, $xoopsUser, $moduleConfig);
    }
 
    public function _getId()
    {
        return isset($_REQUEST['uid']) ? (int)xoops_getrequest('uid') : 0;
    }
 
    public function &_getHandler()
    {
        $handler =& xoops_getmodulehandler('users', 'user');
        return $handler;
    }

    protected function _getPagetitle()
    {
        return Legacy_Utils::getUserName($this->_getId());
    }

    protected function _getPageAction()
    {
        return _MD_USER_LANG_AVATAR_EDIT;
    }
 
    /***
     * This class uses AvatarUploadForm class. It requests three condition
     * which are width limit, height limit and filesize limit.
     *
     * @todo We may have to hand three parameters to constructor.
     */
    public function _setupActionForm()
    {
        $this->mActionForm =new User_AvatarEditForm();
        $this->mActionForm->prepare($this->mAvatarWidth, $this->mAvatarHeight, $this->mAvatarMaxfilesize);
    }
 
    public function isEnableCreate()
    {
        return false;
    }
 
    /***
     *  Return true. This action should not be used by a guest user.
     */
    public function isSecure()
    {
        return true;
    }
 
    /***
     * Check whether a current user can access this action.
     * 1) A specified user has to exist.
     * 2) A current user has to equal the specified user, or a current user has
     *    to be a administrator.
     * @param $controller
     * @param $xoopsUser
     * @param $moduleConfig
     * @return bool
     */
    public function hasPermission(&$controller, &$xoopsUser, $moduleConfig)
    {
        if (!is_object($this->mObject)) {
            return false;
        }
 
        if ($controller->mRoot->mContext->mUser->isInRole('Module.user.Admin')) {
            return true;
        } elseif ($this->mObject->get('uid') == $xoopsUser->get('uid')) {
            // Check count of the system avatar.
            $handler =& xoops_getmodulehandler('avatar', 'user');
            $criteria =new Criteria('avatar_type', 'S');
            if ($handler->getCount($criteria) > 0) {
                return true;
            }
 
            return ($this->mObject->get('posts') >= $this->_mMinPost);
        }
 
        return false;
    }
 
    /***
     * This override method looks like the same method of ListAction, and tries
     * to get system avatars. After, it will call base class.
     * @param $controller
     * @param $xoopsUser
     * @return int
     */
    public function getDefaultView(&$controller, &$xoopsUser)
    {
        $navi =new XCube_PageNavigator(XOOPS_URL . '/edituser.php?op=avatarform&amp;uid=' . $xoopsUser->get('uid'), XCUBE_PAGENAVI_START);
        $handler =& xoops_getmodulehandler('avatar', 'user');
 
        $this->mSystemAvatars[] =& $handler->createNoavatar();
 
        $this->mFilter =new User_AvatarFilterForm($navi, $handler);
        $this->mFilter->fetch();
 
        $criteria = $this->mFilter->getCriteria();
        $t_avatarArr =& $handler->getObjects($criteria);
        foreach (array_keys($t_avatarArr) as $key) {
            $this->mSystemAvatars[] =& $t_avatarArr[$key];
        }
 
        $this->mAvatarSelectForm =new User_AvatarSelectForm();
        $this->mAvatarSelectForm->prepare();
 
        $this->mAvatarSelectForm->load($this->mObject);
 
        return parent::getDefaultView($controller, $xoopsUser);
    }
 
    public function execute(&$controller, &$xoopsUser)
    {
        if (null == $this->mObject) {
            return USER_FRAME_VIEW_ERROR;
        }
 
        if ($this->_mMinPost > 0 && $this->mObject->get('posts') < $this->_mMinPost) {
            return USER_FRAME_VIEW_ERROR;
        }
 
        $this->mActionForm->load($this->mObject);
 
        $this->mActionForm->fetch();
        $this->mActionForm->validate();
 
        if ($this->mActionForm->hasError()) {
            return $this->getDefaultView($controller, $xoopsUser);
        }
 
        $this->mActionForm->update($this->mObject);
 
        return $this->_doExecute() ? USER_FRAME_VIEW_SUCCESS
                                                 : USER_FRAME_VIEW_ERROR;
    }
 
    /***
     * 1) Save avatar file which has been uploaded.
     * 2) If old avatar file exists, remove it.
     * 3) Insert a data to DB with calling base class method.
     */
    public function _doExecute()
    {
        if (null != $this->mActionForm->mFormFile) {
            if (!$this->mActionForm->mFormFile->saveAs(XOOPS_UPLOAD_PATH)) {
                return false;
            }
        }
 
        $this->_resize();
 
        if (null != $this->mActionForm->mOldAvatarFilename && 'blank.gif' != $this->mActionForm->mOldAvatarFilename and null != $this->mActionForm->mFormFile) {
            $avatarHandler =& xoops_getmodulehandler('avatar', 'user');
            $criteria =new Criteria('avatar_file', $this->mActionForm->mOldAvatarFilename);
            $avatarArr =& $avatarHandler->getObjects($criteria);
            if ((is_countable($avatarArr) ? count($avatarArr) : 0) > 0 && is_object($avatarArr[0]) && 'C' == $avatarArr[0]->get('avatar_type')) {
                $avatarHandler->delete($avatarArr[0]);
            }
        }
 
        if (parent::_doExecute()) {
            $avatar =& $this->mActionForm->createAvatar();
            if (null != $avatar) {
                $avatar->set('avatar_name', $this->mObject->get('uname'));
                $avatarHandler =& xoops_getmodulehandler('avatar', 'user');
                $avatarHandler->insert($avatar);
 
                $linkHandler =& xoops_getmodulehandler('avatar_user_link', 'user');
                $linkHandler->deleteAllByUser($this->mObject);
 
                $link =& $linkHandler->create();
                $link->set('user_id', $this->mObject->get('uid'));
                $link->set('avatar_id', $avatar->get('avatar_id'));
 
                $linkHandler->insert($link);
            }
 
            return true;
        } else {
            return false;
        }
    }

    public function _resize()
    {
        $source = null;
        //resize requires GD library
        if (! function_exists('imagecreatefromjpeg') || ! function_exists('imagecreatefrompng') || ! function_exists('imagecreatefromgif')) {
            return;
        }
 
        if (! $formFile = $this->mActionForm->mFormFile) {
            return;
        }
        $filePath = XOOPS_UPLOAD_PATH.'/'.$formFile->getFileName();
        [$width, $height, $type, $attr]=getimagesize($filePath);
        switch ($type) {
            case 2:
            $source = imagecreatefromjpeg($filePath);
            break;
            case 1:
            $source = imagecreatefromgif($filePath);
            break;
            case 3:
            $source = imagecreatefrompng($filePath);
            break;
        }
        $size = $this->_getResizedSize($width, $height, $this->mAvatarWidth, $this->mAvatarHeight);
        $result = function_exists('imagecreatetruecolor') ? imagecreatetruecolor($size['width'], $size['height']) : imagecreate($size['width'], $size['height']);
        if (!imagecopyresampled($result, $source, 0, 0, 0, 0, $size['width'], $size['height'], $width, $height)) {
            die(); // TODO redirect message
        }
        switch ($type) {
            case 2:
            imagejpeg($result, $filePath);
            break;
            case 1:
            imagegif($result, $filePath);
            break;
            case 3:
            imagepng($result, $filePath);
            break;
        }
    }

    public function _getResizedSize(/*** int ***/ $width, /*** int ***/ $height, /*** int ***/ $maxWidth, /*** int ***/ $maxHeight)
    {
        if (min($width, $height, $maxWidth, $maxHeight) < 1) {
            echo $width .'/'. $height .'/'. $maxWidth .'/'. $maxHeight;
            die();
        }
        $scale = min($maxWidth / $width, $maxHeight / $height, 1);
        return ['width' => (int)($width * $scale), 'height' => (int)($height * $scale)];
    }
 
    public function executeViewInput(&$controller, &$xoopsUser, &$render)
    {
        $render->setTemplateName('user_avatar_edit.html');
        $render->setAttribute('actionForm', $this->mActionForm);
        $render->setAttribute('thisUser', $this->mObject);
 
        $render->setAttribute('allowUpload', $this->_mAllowUpload && $this->mObject->get('posts') >= $this->_mMinPost);
        $render->setAttribute('avatarWidth', $this->mAvatarWidth);
        $render->setAttribute('avatarHeight', $this->mAvatarHeight);
        $render->setAttribute('avatarMaxfilesize', $this->mAvatarMaxfilesize);
 
        $render->setAttribute('pageNavi', $this->mFilter->mNavi);
        $render->setAttribute('systemAvatars', $this->mSystemAvatars);
        $render->setAttribute('avatarSelectForm', $this->mAvatarSelectForm);
    }
 
    public function executeViewSuccess(&$controller, &$xoopsUser, &$render)
    {
        $controller->executeForward(XOOPS_URL . '/userinfo.php?uid=' . $this->mActionForm->get('uid'));
    }
 
    public function executeViewError(&$controller, &$xoopsUser, &$render)
    {
        $controller->executeRedirect(XOOPS_URL . '/userinfo.php?uid=' . $this->mActionForm->get('uid'), 1, _MD_USER_ERROR_DBUPDATE_FAILED);
    }
}