oxfile.php

Go to the documentation of this file.

<?php

class oxFile extends oxBase
{
    const NO_USER = 2;

    protected $_sCoreTable = 'oxfiles';

    protected $_sClassName = 'oxfile';

    protected $_sRelativeFilePath = null;

    protected $_blIsPaid = null;

    protected $_sDownloadLink = null;

    protected $_blHasValidDownloads = null;

    protected $_sManualUploadDir = "uploads";

    public function __construct()
    {
        parent::__construct();
        $this->init();
    }

    public function processFile( $sFileIndex )
    {
        $aFileInfo = $this->getConfig()->getUploadedFile( $sFileIndex );

        $this->_checkArticleFile( $aFileInfo );

        $sFileHash = $this->_getFileHash( $aFileInfo['tmp_name'] );
        $this->oxfiles__oxstorehash = new oxField( $sFileHash, oxField::T_RAW );
        $sUploadTo = $this->getStoreLocation();

        if ( !$this->_uploadFile( $aFileInfo['tmp_name'], $sUploadTo ) ) {
            throw new oxException( 'EXCEPTION_COULDNOTWRITETOFILE' );
        }

    }

    protected function _checkArticleFile( $aFileInfo )
    {
        //checking params
        if ( !isset( $aFileInfo['name'] ) || !isset( $aFileInfo['tmp_name'] ) ) {
            throw new oxException( 'EXCEPTION_NOFILE' );
        }

        // error uploading file ?
        if ( isset( $aFileInfo['error'] ) && $aFileInfo['error'] ) {
            throw new oxException( 'EXCEPTION_FILEUPLOADERROR_'.( (int) $aFileInfo['error'] ) );
        }

    }

    protected function _getBaseDownloadDirPath()
    {
        $sConfigValue = oxRegistry::getConfig()->getConfigParam( 'sDownloadsDir' );

        //Unix full path is set
        if ( $sConfigValue && $sConfigValue[0] == DIR_SEP) {
            return $sConfigValue;
        }

        //relative path is set
        if ( $sConfigValue ) {
            $sPath = getShopBasePath() . DIR_SEP . $sConfigValue;
            return $sPath;
        }

        //no path is set
        $sPath = getShopBasePath() . "/out/downloads/";
        return $sPath;
    }

    public function getStoreLocation()
    {
        $sPath  = $this->_getBaseDownloadDirPath();
        $sPath .= DIR_SEP .  $this->_getFileLocation();
        return $sPath;
    }

    protected function _getFileLocation()
    {
        $this->_sRelativeFilePath = '';
        $sFileHash = $this->oxfiles__oxstorehash->value;
        $sFileName = $this->oxfiles__oxfilename->value;

        //security check for demo shops
        if ($this->getConfig()->isDemoShop()) {
            $sFileName = basename($sFileName);
        }

        if ($this->isUploaded()) {
            $this->_sRelativeFilePath  = $this->_getHashedFileDir($sFileHash);
            $this->_sRelativeFilePath .= DIR_SEP .  $sFileHash;
        } else {
            $this->_sRelativeFilePath = DIR_SEP . $this->_sManualUploadDir . DIR_SEP . $sFileName;
        }

        return $this->_sRelativeFilePath;
    }

    protected function _getHashedFileDir( $sFileHash )
    {
        $sDir = substr($sFileHash, 0, 2);
        $sAbsDir = $this->_getBaseDownloadDirPath() . DIR_SEP . $sDir;

        if (!is_dir($sAbsDir)) {
            mkdir($sAbsDir, 0755);
        }
        return $sDir;
    }

    protected function _getFileHash( $sFileName )
    {
        return md5_file( $sFileName );
    }

    protected function _uploadFile( $sSource, $sTarget )
    {
        $blDone = move_uploaded_file( $sSource, $sTarget );

        if ( $blDone ) {
            $blDone = @chmod( $sTarget, 0644 );
        }

        return $blDone;
    }

    public function isUploaded()
    {
        $blHashed = false;
        if ($this->oxfiles__oxstorehash->value) {
            $blHashed = true;
        }
        return $blHashed;
    }

    public function delete( $sOxId = null )
    {
        $sOxId = $sOxId ? $sOxId : $this->getId();

        $this->load($sOxId);
        // if record cannot be delete, abort deletion
        if ($blDeleted = parent::delete( $sOxId ) ) {
            $this->_deleteFile( );
        }

        return $blDeleted;
    }

    protected function _deleteFile()
    {
        if (!$this->isUploaded()) {
            return false;
        }
        $sHash = $this->oxfiles__oxstorehash->value;
        $oDb = oxDb::getDb();
        $iCount = $oDb->getOne(
            'SELECT COUNT(*) FROM `oxfiles` WHERE `OXSTOREHASH` = ' . $oDb->quote( $sHash ), false, false );
        if (!$iCount) {
            $sPath  = $this->getStoreLocation();
            unlink($sPath);
        }
    }

    protected function _getFilenameForUrl()
    {
        return rawurlencode($this->oxfiles__oxfilename->value);
    }

    public function download()
    {
        $oUtils = oxRegistry::getUtils();
        $sFileName = $this->_getFilenameForUrl();
        $sFileLocations = $this->getStoreLocation();

        if (  !$this->exist() ) {
            throw new oxException( 'EXCEPTION_NOFILE' );
        }

        $oUtils->setHeader("Pragma: public");
        $oUtils->setHeader("Expires: 0");
        $oUtils->setHeader("Cache-Control: must-revalidate, post-check=0, pre-check=0, private");
        $oUtils->setHeader('Content-Disposition: attachment;filename=' . $sFileName);
        $oUtils->setHeader("Content-Type: application/octet-stream");
        if ( $iFileSize = $this->getSize() ) {
            $oUtils->setHeader("Content-Length: " . $iFileSize);
        }
        readfile( $sFileLocations );
        $oUtils->showMessageAndExit( null );
    }

    public function exist()
    {
        return file_exists( $this->getStoreLocation() );
    }

    public function hasValidDownloads()
    {
        if ( $this->_blHasValidDownloads == null ) {
            $this->_blHasValidDownloads = false;
            $sNow   = date( 'Y-m-d H:i:s', oxRegistry::get("oxUtilsDate")->getTime() );
            $sFileId = $this->getId();

            $oDb = oxDb::getDb();

            $sSql = "SELECT
                        `oxorderfiles`.`oxid`
                     FROM `oxorderfiles`
                        LEFT JOIN `oxorderarticles` ON `oxorderarticles`.`oxid` = `oxorderfiles`.`oxorderarticleid`
                        LEFT JOIN `oxorder` ON `oxorder`.`oxid` = `oxorderfiles`.`oxorderid`
                     WHERE `oxorderfiles`.`oxfileid` = " . $oDb->quote($sFileId) . "
                        AND ( ! `oxorderfiles`.`oxmaxdownloadcount` OR `oxorderfiles`.`oxmaxdownloadcount` > `oxorderfiles`.`oxdownloadcount`)
                        AND ( `oxorderfiles`.`oxvaliduntil` = '0000-00-00 00:00:00' OR `oxorderfiles`.`oxvaliduntil` > '{$sNow}' )
                        AND `oxorder`.`oxstorno` = 0
                        AND `oxorderarticles`.`oxstorno` = 0";

            if ( $oDb->getOne( $sSql ) ) {
                $this->_blHasValidDownloads = true;
            }
        }
        return $this->_blHasValidDownloads;
    }

    public function getMaxDownloadsCount()
    {
        $iMaxCount = $this->oxfiles__oxmaxdownloads->value;
        //if value is -1, takes global options
        if ( $iMaxCount < 0) {
            $iMaxCount = $this->getConfig()->getConfigParam( "iMaxDownloadsCount" );
        }
        return $iMaxCount;
    }

    public function getMaxUnregisteredDownloadsCount()
    {
        $iMaxCount = $this->oxfiles__oxmaxunregdownloads->value;
        //if value is -1, takes global options
        if ( $iMaxCount < 0) {
            $iMaxCount = $this->getConfig()->getConfigParam( "iMaxDownloadsCountUnregistered" );
        }
        return $iMaxCount;
    }

    public function getLinkExpirationTime()
    {
        $iExpTime = $this->oxfiles__oxlinkexptime->value;
        //if value is -1, takes global options
        if ( $iExpTime < 0) {
            $iExpTime = $this->getConfig()->getConfigParam( "iLinkExpirationTime" );
        }
        return $iExpTime;
    }

    public function getDownloadExpirationTime()
    {
        $iExpTime = $this->oxfiles__oxdownloadexptime->value;
        //if value is -1, takes global options
        if ( $iExpTime < 0) {
            $iExpTime = $this->getConfig()->getConfigParam( "iDownloadExpirationTime" );
        }
        return $iExpTime;
    }

    public function getSize()
    {
        $iSize = 0;
        if ( $this->exist() ) {
            $iSize = filesize( $this->getStoreLocation() );
        }
        return $iSize;
    }

}