snap2/content/SnapExternalFile.php5

<?php

class SnapExternalFile extends SObject {
    protected $path = "";
    protected $url = "";
    protected $name = "";
    protected $versionId = "";
    protected $exists = false;
    protected $acceptableFileTypes = array();

    public function __construct($version, $array = "") {
        parent::__construct();

        $this->version = $version;
        if($array != "")
            $this->load($array);
    }

    public function getPath() {
        $path = Snap2::getMediaPathBase() . '/' . $this->path;
        return $path;
    }

    public function getURL() {
        return Snap2::getMediaURLBase() . '/' . $this->url;
    }

    public function unzip($callIt) {
        $zipFile = Snap2::getMediaPathBase() . '/' . $this->path;
        $extractDir = substr($this->path,0,-4) . '/';
        $extractDirFull = Snap2::getMediaPathBase() . '/' . $extractDir;
        $extractURL = substr($this->url, 0,-4) . '/';
        $extractURLFull = Snap2::getMediaPathBase() . '/' . $extractURL;
        if(!mkdir($extractDirFull, 0777, true)) return false;
        if(!copy($zipFile, $extractDirFull.'zipFile.zip')) return false;
        if(!chdir($extractDirFull)) return false;
        if(!shell_exec("unzip 'zipFile.zip'")) return false;
        // awful awful hack to make sure that zip files with an embedded directory have the contents
        //  of that directory moved up to the toplevel
        $dirs = scandir(substr($zipFile, 0, -4));
        $dontMoveUp = false;
        foreach($dirs as $dir) {
            if($dir == '.' || $dir == '..')
                continue;
            if($dir == 'applet' || $dir == 'documentation') {
                $dontMoveUp = true;
                break;
            }
        }
        if(!$dontMoveUp) {
            $dir = '';
            foreach($dirs as $d) {
                if($d == '.' || $d == '..' || $d == '__MACOSX' || substr($d, -4) == '.zip')
                    continue;
                $dir = $d;
                break;
            }
            shell_exec($cmd = "mv $extractDirFull$dir/* $extractDirFull");
            shell_exec($cmd = "rm -rf $extractDirFull$dir");
        }
        /*
        if(in_array('__MACOSX', $dirs)) count() == 4 ||
            (count($dirs) == 5 && ($dirs[3] == '__MACOSX' || $dirs[4] == '__MACOSX'))) {
            shell_exec($cmd = "mv $extractDirFull/$dirs[2]/* $extractDirFull");
            shell_exec($cmd = "rm -rf $extractDirFull/$dirs[2]");
//          rmdir("$extractDirFull/$dirs[2]");
        }
        */
        if(!unlink($extractDirFull.'zipFile.zip')) return false;

        $newDir = new SnapExternalFile($this->version);
        $newDir->load(array('path' => $extractDir, 'url' => $extractURL, 'name' => basename($extractDir)));
        return $newDir;
    }

    public function getName() {
        return $this->name;
    }

    public function getArray() {
        return array('path' => $this->path, 'url' => $this->url, 'name' => $this->name);
    }

    public function load($array) {
        if(!is_array($array)) {
            $this->setError("load() expects array from database content");
            return false;
        }

        // assume these are all correct
        $this->path = $array['path'];
        $this->url = $array['url'];
        $this->name = $array['name'];
        $this->exists = true;

        return true;
    }

    public function setAcceptable($fileTypes) {
        if (is_array($fileTypes))
            $this->acceptableFileTypes = $fileTypes;
        else {
            $this->setError("Acceptable File Types not an array!");
            return false;
        }
    }

    public function weedFiles($directory = 'default') {
        if ($directory == 'default')
            $directory = $this->path;
        foreach(glob(rtrim($directory, '/').'/*') as $file) {
            if (is_dir($file) && !is_link($file)) {
                $this->weedFiles($file);
            }
            else {
                $e = substr(strrchr($file, '.'), 1);
                $flag = false;
                foreach($this->acceptableFileTypes as $accepted) {
                    if (($e == $accepted))
                        $flag = true;
                }
                if (!$flag)
                    unlink($file);
            }
        }

        return true;
    }

    public function create($tmpFile, $originalName, $name = "") {
        if($this->exists) {
            $this->setError("Cannot create a file when this file already exists (use update instead!)");
            return false;
        }
        list($this->url, $this->path) = $this->generateFilePaths($tmpFile, $originalName);
        $realPath = Snap2::getMediaPathBase() . '/' . $this->path;
        if(substr($realPath, -1) == '/')
            $dirname = dirname(substr($realPath, 0, -1));
        else
            $dirname = dirname($realPath);
        if(!is_dir($dirname) && !@mkdir($dirname, 0755, true)) {
            $this->setError("Could not create directory '" . dirname($realPath) . "'");
            return false;
        }
        if(substr($realPath, -1) != '/') {
            if(!@copy($tmpFile, $realPath)) {
                $this->setError("Could not copy '$tmpFile' to '$realPath'");
                @rmdir($dirname);
                return false;
            }
        }
        else {
            $dest = $realPath;
            $src = $tmpFile;
            system("/bin/cp -Rp $src $dest", $retval);
            if($retval != 0) {
                $this->setError("Could not copy '$tmpFile' to '$realPath' recursively");
                @rmdir($dirname);
                return false;
            }
        }
        $this->exists = true;
        if($name == "")
            $this->name = $originalName;
        else
            $this->name = $name;
        $query = 'INSERT INTO ExternalFiles SET path = \'' . mysql_escape_string($this->path) . '\', versionId = '
                        . $this->version->getId();
        SnapDBI::query($query);
        return true;
    }

    public function update($tmpFile, $originalName, $name = "") {
        if(!$this->exists) {
            $this->setError("Cannot update a non-existent file");
            return false;
        }
        // only intending to update the name...
        if($tmpFile != "")
            copy($tmpFile, Snap2::getMediaPathBase() . '/' .$this->path);
        if($name == "")
            $this->name = $originalName;
        else
            $this->name = $name;
        return true;
    }

    public function copy($newName = "") {
        if(!$this->exists) {
            $this->setError("Cannot copy a non-existent file");
            return null;
        }
        if($newName == "")
            $newName = $this->name;
        $nfile = new SnapExternalFile($this->version);
        if(!$nfile->create(Snap2::getMediaPathBase() . '/' . $this->path, $this->path, $newName)) {
            $this->setError('Could not create new copy: <ul><li>' . implode('</li><li>', $nfile->getError()) . '</li></ul>');
            return null;
        }
        return $nfile;
    }

    public function delete() {
        if(!$this->exists) {
            $this->setError("Cannot delete a non-existent file");
            return false;
        }
        if(substr($this->path, -1) == "/")
            system("/bin/rm -rf " . Snap2::getMediaPathBase() . '/' . $this->path);
        else
            @unlink(Snap2::getMediaPathBase() . '/' . $this->path);
        $query = 'DELETE FROM ExternalFiles WHERE path = \'' . mysql_escape_string($this->path)
                    . '\' AND versionId = ' . $this->version->getId();
        SnapDBI::query($query);
        $this->path = "";
        $this->url = "";
        $this->name = "";
        $this->exists = false;
        return true;
    }

    public function updateDB() {
        $query = 'INSERT INTO ExternalFiles (path, versionId) VALUES (\'' . $this->path . '\', ' . $this->version->getId()
                    . ') ON DUPLICATE KEY UPDATE path=\'' . $this->path . '\',versionId = ' . $this->version->getId();
        if(!SnapDBI::query($query))
            return false;
        else
            return true;
    }

    private function generateRelPath($fileName, $origFileName) {
        if(is_dir($fileName))
            $contents = implode(':', scandir($fileName));
        else if(is_file($fileName))
            $contents = @file_get_contents($fileName);
        else {
            $this->setError("No such file: '$fileName'");
            return null;
        }
        $hash = MD5($contents . microtime() . $fileName . $origFileName);
        $hash = base64_encode($hash);
        $hash = strtr($hash, "/+", "-_");
        $hash = rtrim($hash, "=");
        $tmp = strrchr($origFileName, ".");
        $suffix = substr($tmp, 1);
        $path = $hash[0] . "/" . $hash[1] . "/" . $hash[2]
            . "/" . substr($hash, 3);
        if(is_dir($fileName))
            $path .= '/';
        else
            $path .= "." . $suffix;
        return $path;
    }

    private function generateFilePaths($fileName, $origFileName) {
        $path = $this->generateRelPath($fileName, $origFileName);
//      $arr = array("/" . Snap2::getMediaPath() . "/" . $path,
//          Snap2::getMediaRoot() . "/" . Snap2::getMediaPath() . "/" . $path);
        $arr = array($path, $path);
        return $arr;
    }
}

?>

---