ifhub.club/application/classes/modules/property/entity/ValueTypeFile.entity.class.php

<?php
/*
 * LiveStreet CMS
 * Copyright © 2013 OOO "ЛС-СОФТ"
 *
 * ------------------------------------------------------
 *
 * Official site: www.livestreetcms.com
 * Contact e-mail: office@livestreetcms.com
 *
 * GNU General Public License, version 2:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 *
 * ------------------------------------------------------
 *
 * @link http://www.livestreetcms.com
 * @copyright 2013 OOO "ЛС-СОФТ"
 * @author Maxim Mzhelskiy <rus.engine@gmail.com>
 *
 */

/**
 * Объект управления типом file
 *
 * @package application.modules.property
 * @since 2.0
 */
class ModuleProperty_EntityValueTypeFile extends ModuleProperty_EntityValueType
{

    public function getValueForDisplay()
    {
        return $this->getFileFullName();
    }

    public function validate()
    {
        $oValue = $this->getValueObject();
        $oProperty = $oValue->getProperty();
        $iPropertyId = $oProperty->getId();

        $mValue = $this->getValueForValidate();
        if (isset($mValue['remove']) and $mValue['remove']) {
            $this->setValueForValidate(array('remove' => true));
        }

        $sFileName = $this->_getValueFromFiles($iPropertyId, 'name');
        $sFileTmpName = $this->_getValueFromFiles($iPropertyId, 'tmp_name');
        $sFileError = $this->_getValueFromFiles($iPropertyId, 'error');
        $sFileSize = $this->_getValueFromFiles($iPropertyId, 'size');

        if (!$sFileTmpName) {
            if ($oProperty->getValidateRuleOne('allowEmpty')) {
                return true;
            } elseif ($aFilePrev = $oValue->getDataOne('file') and isset($aFilePrev['path'])) {
                return true;
            } else {
                return 'Необходимо выбрать файл';
            }
        }
        /**
         * Проверяем на ошибки
         */
        if ($sFileError and $sFileError != UPLOAD_ERR_NO_FILE) {
            return "При загрузке файла возникла ошибка - {$sFileError}";
        }
        /**
         * На корректность загрузки
         */
        if (!$sFileName or !$sFileTmpName) {
            return false;
        }
        /**
         * На ограниечение по размеру файла
         */
        if ($iSizeKb = $oProperty->getValidateRuleOne('size_max') and $iSizeKb * 1025 < $sFileSize) {
            return "Превышен размер файла, максимальный {$iSizeKb}Kb";
        }
        /**
         * На допустимые типы файлов
         */
        $aPath = pathinfo($sFileName);
        if (!isset($aPath['extension']) or !$aPath['extension']) {
            return false;
        }
        if ($aTypes = $oProperty->getParam('types') and !in_array($aPath['extension'], $aTypes)) {
            return 'Неверный тип файла, допустимы ' . join(', ', $aTypes);
        }
        /**
         * Пробрасываем данные по файлу
         */
        $this->setValueForValidate(array(
            'name'     => $sFileName,
            'tmp_name' => $sFileTmpName,
            'error'    => $sFileError,
            'size'     => $sFileSize,
        ));
        return true;
    }

    protected function _getValueFromFiles($iId, $sName)
    {
        if (isset($_FILES['property'][$sName][$iId]['file'])) {
            return $_FILES['property'][$sName][$iId]['file'];
        }
        return null;
    }

    /**
     * Устанавливает значение после валидации конкретного поля, а не всех полей
     * Поэтому здесь нельзя сохранять файл, это нужно делать в beforeSaveValue()
     *
     * @param $aValue
     */
    public function setValue($aValue)
    {
        $oValue = $this->getValueObject();
        /**
         * Просто пробрасываем данные
         */
        if ($aValue) {
            $oValue->setDataOne('file_raw', $aValue);
        }
    }

    /**
     * Дополнительная обработка перед сохранением значения
     * Здесь нужно выполнять основную загрузку файла
     */
    public function beforeSaveValue()
    {
        $oValue = $this->getValueObject();
        $oProperty = $oValue->getProperty();
        if (!$aFile = $oValue->getDataOne('file_raw')) {
            return true;
        }
        $oValue->setDataOne('file_raw', null);
        /**
         * Удаляем предыдущий файл
         */
        if (isset($aFile['remove']) or isset($aFile['name'])) {
            if ($aFilePrev = $oValue->getDataOne('file')) {
                $this->RemoveFile($aFilePrev['path']);
                $oValue->setDataOne('file', array());
                $oValue->setValueVarchar(null);
            }
        }

        if (isset($aFile['name'])) {
            /**
             * Выполняем загрузку файла
             */
            $aPathInfo = pathinfo($aFile['name']);
            $sExtension = isset($aPathInfo['extension']) ? $aPathInfo['extension'] : 'unknown';
            $sFileName = func_generator(20) . '.' . $sExtension;
            /**
             * Копируем загруженный файл
             */
            $sDirTmp = Config::Get('path.tmp.server') . '/property/';
            if (!is_dir($sDirTmp)) {
                @mkdir($sDirTmp, 0777, true);
            }
            $sFileTmp = $sDirTmp . $sFileName;

            if (move_uploaded_file($aFile['tmp_name'], $sFileTmp)) {
                $sDirSave = Config::Get('path.root.server') . $oProperty->getSaveFileDir();
                if (!is_dir($sDirSave)) {
                    @mkdir($sDirSave, 0777, true);
                }
                $sFilePath = $sDirSave . $sFileName;
                /**
                 * Сохраняем файл
                 */
                if ($sFilePathNew = $this->SaveFile($sFileTmp, $sFilePath, null, true)) {
                    /**
                     * Сохраняем данные о файле
                     */
                    $oValue->setDataOne('file', array(
                        'path'      => $sFilePathNew,
                        'size'      => filesize($sFilePath),
                        'name'      => htmlspecialchars($aPathInfo['filename']),
                        'extension' => htmlspecialchars($aPathInfo['extension']),
                    ));
                    /**
                     * Сохраняем уникальный ключ для доступа к файлу
                     */
                    $oValue->setValueVarchar(func_generator(32));
                    return true;
                }
            }
        }
    }

    public function prepareValidateRulesRaw($aRulesRaw)
    {
        $aRules = array();
        $aRules['allowEmpty'] = isset($aRulesRaw['allowEmpty']) ? false : true;

        if (isset($aRulesRaw['size_max']) and is_numeric($aRulesRaw['size_max'])) {
            $aRules['size_max'] = (int)$aRulesRaw['size_max'];
        }
        return $aRules;
    }

    public function prepareParamsRaw($aParamsRaw)
    {
        $aParams = array();

        $aParams['types'] = array();
        if (isset($aParamsRaw['types']) and is_array($aParamsRaw['types'])) {
            foreach ($aParamsRaw['types'] as $sType) {
                if ($sType) {
                    $aParams['types'][] = htmlspecialchars($sType);
                }
            }
        }
        $aParams['access_only_auth'] = isset($aParamsRaw['access_only_auth']) ? true : false;

        return $aParams;
    }

    public function getParamsDefault()
    {
        return array(
            'types' => array(
                'zip'
            ),
        );
    }

    public function removeValue()
    {
        $oValue = $this->getValueObject();
        /**
         * Удаляем файл
         */
        if ($aFilePrev = $oValue->getDataOne('file')) {
            $this->RemoveFile($aFilePrev['path']);
        }
    }

    public function getFileFullName()
    {
        $oValue = $this->getValueObject();
        if ($aFilePrev = $oValue->getDataOne('file')) {
            return $aFilePrev['name'] . '.' . $aFilePrev['extension'];
        }
        return null;
    }

    /**
     * Сохраняет(копирует) файл на сервер
     * Если переопределить данный метод, то можно сохранять файл, например, на Amazon S3
     *
     * @param string $sFileSource Полный путь до исходного файла
     * @param string $sFileDest Полный путь до файла для сохранения с типом, например, [server]/home/var/site.ru/book.pdf
     * @param int|null $iMode Права chmod для файла, например, 0777
     * @param bool $bRemoveSource Удалять исходный файл или нет
     * @return bool | string    При успешном сохранении возвращает относительный путь до файла с типом, например, [relative]/image.jpg
     */
    protected function SaveFile($sFileSource, $sFileDest, $iMode = null, $bRemoveSource = false)
    {
        if ($this->Fs_SaveFileLocal($sFileSource, $this->Fs_GetPathServer($sFileDest), $iMode, $bRemoveSource)) {
            return $this->Fs_MakePath($this->Fs_GetPathRelativeFromServer($sFileDest), ModuleFs::PATH_TYPE_RELATIVE);
        }
        return false;
    }

    /**
     * Удаляет файл
     * Если переопределить данный метод, то можно удалять файл, например, с Amazon S3
     *
     * @param string $sPathFile Полный путь до файла с типом, например, [relative]/book.pdf
     *
     * @return mixed
     */
    protected function RemoveFile($sPathFile)
    {
        $sPathFile = $this->Fs_GetPathServer($sPathFile);
        return $this->Fs_RemoveFileLocal($sPathFile);
    }

    public function DownloadFile()
    {
        $oValue = $this->getValueObject();
        if ($aFilePrev = $oValue->getDataOne('file')) {
            $this->Tools_DownloadFile($this->Fs_GetPathServer($aFilePrev['path']),
                $aFilePrev['name'] . '.' . $aFilePrev['extension'], $aFilePrev['size']);
        }
        return false;
    }
}