snap2/objects/SnapDirectory.php5

<?php

final class SnapDirectory extends SnapFile {
    public static $ATTRIBUTES = array('id', 'name', 'description', 'created', 'modified',
                                            'canonParentId', 'refCount', 'oldParentId');

    public function __construct($id = "") {
        parent::__construct('Directory', array_merge(array_flip(self::$ATTRIBUTES),
                                        array('maxDirOrdinal' => array($this, 'loadMaxDirOrdinal')),
                                        array('maxResOrdinal' => array($this, 'loadMaxResOrdinal'))),
                            self::$ATTRIBUTES, $id);
    }

    public function toCacheDump() {
        $name = $this->get('name');
        $cparent = $this->get('canonParentId');
        return "Name: $name; Canon. Parent: $cparent";
    }

    protected function doDestroy() {
        // unlink all children
        $contents = $this->listContents();
        foreach($contents as $c) {
            if(count($c->getParents()) > 1)
                $c->unlinkFrom(-$this->getId());
            else
                $c->delete();
        }
        return true;
    }

    protected function loadMaxDirOrdinal() {
        $id = $this->get('id');
        $query = "SELECT MAX(ordinal) FROM DirectoryLink WHERE parentId = $id";
        if(!($result = SnapDBI::query($query, true))) {
            $this->setError('Could not load maximum directory ordinal for this directory');
            return false;
        }
        $this->set('maxDirOrdinal', $result[0]['MAX(ordinal)']);
        SnapCache::updateById($this->getType(), $this->getId());
        return true;
    }

    protected function loadMaxResOrdinal() {
        $id = $this->get('id');
        $query = "SELECT MAX(ordinal) FROM ResourceLink WHERE parentId = $id";
        if(!($result = SnapDBI::query($query, true))) {
            $this->setError('Could not load maximum resource ordinal for this directory');
            return false;
        }
        $this->set('maxResOrdinal', $result[0]['MAX(ordinal)']);
        SnapCache::updateById($this->getType(), $this->getId());
        return true;
    }


    /*
     * Static Factory Methods
     *
     * These methods retrieve directory objects and are the only correct way to get an existing
     * directory into object form.
     */

    public static function retrieve($id) {
        // make sure Snap2 is connected to a DB
        if(!Snap2::checkInit()) return null;

        // validate ID
        if(!ctype_digit((string) $id) || $id <= 0) {
            self::setStaticError('ID must be numeric');
            return null;
        }

        // first check the cache to see if we have already instantiated this SnapDirectory object
        $dir = SnapCache::getById('Directory', $id);
        if($dir != null)    // ...we have, so return the cached object
            return $dir;

        // we need to create the object and load it from the DB with autopopulate
        $dir = new SnapDirectory($id);
        if(!($dir->getId() > 0))
            return null;

        // store the directory object in the cache for later use
        SnapCache::putById('Directory', $id, $dir);

        return $dir;
    }

    public static function lookup($path) {
        // make sure Snap2 is connected to the DB and initialized
        if(!Snap2::checkInit()) return null;

        // make sure the path is a valid directory path (starts with /, ends with /, nothing but
        //  alphanumeric characters, dashes, underscores and dollar signs in the path parts)
        if(!preg_match('/^\s*((\/[a-zA-Z0-9\$\-_.]*)+\/)\s*$/', $path, $matches)) {
            self::setStaticError('Invalid path: \'' . $path . '\'');
            return null;
        }

        // the first entry is the whole match not including leading and trailing whitespace
        $path = $matches[1];

        // check to see if we already have this directory in the cache
        // NOTE: we may have the directory object, but not by this path (that case will be handled
        //   later)
        $dir = SnapCache::getByPath('Directory', $path);
        if($dir != null)
            return $dir;

        // break path into parts
        $pathParts = explode('/', $path);

        // build a recursive self-join query
        // the idea is to successively join DirectoryLink onto itself with each join corresponding
        // to one of the path parts
        $query = 'SELECT ' . implode(',', self::$ATTRIBUTES) . ' FROM Directory';
        $where = ' WHERE ';
        for($i = 1, $j = count($pathParts) - 2; $i < count($pathParts) - 1; $i++, $j--) {
            $query .= ' LEFT JOIN DirectoryLink AS DirectoryLink' . $i . ' ON DirectoryLink' . $i
                . '.childId = ' . ($i == 1 ? 'Directory.id' : ('DirectoryLink' . ($i - 1) . '.parentId'));
            $where .= ' DirectoryLink' . $j . '.shortName = BINARY \'' . $pathParts[$i] . '\' AND ';
        }
        $query .= rtrim($where, ' AND ');
        $result = SnapDBI::query($query, true);
        if($result === false)
            return null;

        if(count($result) == 0)
            return null;
        else if(count($result) != 1)
            self::setStaticWarning('Multiple results for path \'' . $path . '\'!  Run Snap consistency check please.');

        // now we get to check if we already have this directory in the cache, but with a different
        // path associated with it
        $dir = SnapCache::getById('Directory', $result[0]['id']);
        if($dir != null) {
            // ...and make sure to add this new path to the cache
            SnapCache::putByPath('Directory', $path, $dir);
            return $dir;
        }

        // fill in the directory object with info from the query
        $dir = new SnapDirectory();
        foreach(self::$ATTRIBUTES as $a)
            $dir->set($a, $result[0][$a]);

        // and save in the cache, by id and by path
        SnapCache::putById('Directory', $dir->getId(), $dir);
        SnapCache::putByPath('Directory', $path, $dir);

        return $dir;
    }

    /*
     * Capability methods
     */

    public function canCreateDirectory($shortName = false) {
        if($shortName !== false) {
            if($shortName == '' || !preg_match('/^[a-zA-Z0-9\_\-\.]+$/', $shortName)) {
                $this->setReason("Invalid shortName: '$shortName'");
                return false;
            }
            $shortName = substr($shortName, 0, 64);

            $query = 'SELECT shortName FROM DirectoryLink WHERE '
                . 'DirectoryLink.parentId = ' . $this->getId() . ' AND shortName = BINARY \'' . $shortName . '\'';
            // SnapDBI will set an error, so we can just return false
            if(!SnapDBI::query($query))
                return false;

            // free result is called because we did not get the result in array form from
            // SnapDBI::query(), so it is sitting around in SnapDBI and needs to be freed after use
            if(SnapDBI::getNumRows() != 0) {
                SnapDBI::freeResult();
                $this->setReason("Subdirectory '$shortName' already exists!");
                return false;
            }
            SnapDBI::freeResult();
        }

        if(!$this->getPermission()->mayCreateDirectory()) {
            $this->setReason('Permission denied');
            return false;
        }

        return true;
    }

    public function canCreateResource($shortName = false, $contentType = SnapResource::TYPE_STDXML) {
        if($shortName !== false) {
            if($shortName == '' || !preg_match('/^[a-zA-Z0-9\_\-\.]+$/', $shortName)) {
                $this->setReason("Invalid shortName: '$shortName'");
                return false;
            }
            $shortName = substr($shortName, 0, 64);

            $query = 'SELECT shortName FROM ResourceLink WHERE '
                . 'ResourceLink.parentId = ' . $this->getId() . ' AND shortName = BINARY \'' . $shortName . '\'';
            if(!SnapDBI::query($query))
                return false;

            if(SnapDBI::getNumRows() != 0) {
                SnapDBI::freeResult();
                $this->setReason("Subresource '$shortName' already exists!");
                return false;
            }
            SnapDBI::freeResult();
        }

        if(!ctype_digit((string) $contentType) || !SnapContent::isValidType($contentType)) {
            $this->setReason('Invalid content type: ' . $contentType);
            return false;
        }

        if(!$this->getPermission()->mayCreateResource()) {
            $this->setReason('Permission denied');
            return false;
        }

        return true;
    }

    /*
     * Standard Public Interface Methods
     */

    public function createDirectory($shortName, $name = "", $description = "") {
        if(!$this->checkValid()) return false;

        // start the transaction here so that any DB checks we do in canCreateDirectory() aren't
        // done with invalid state
        if(!SnapDBI::startTransaction())
            return null;

        if($name == "")
            $name = $shortName;

        if($shortName === false || !$this->canCreateDirectory($shortName)) {
            $this->setError('Cannot create directory because '. $this->getReason());
            SnapDBI::cancelTransaction();
            return false;
        }

        $name = mysql_escape_string($name);
        $description = mysql_escape_string($description);

        // refCount gets updated by mklink() below
        $query = "INSERT INTO Directory (name, description, created, canonParentId, refCount) VALUES "
            . "('$name', '$description', CURRENT_TIMESTAMP, " . $this->getId() . ", 0)";
        if(!SnapDBI::query($query)) {
            SnapDBI::cancelTransaction();
            return null;
        }
        $id = SnapDBI::getInsertId();

        // copy permissions from this object to the newly created subdirectory
        if(!SnapDirectoryUserPermission::copy($this->getId(), $id) ||
            !SnapDirectoryGroupPermission::copy($this->getId(), $id))
        {
            SnapDBI::cancelTransaction();
            return null;
        }

        $dir = new SnapDirectory();
        $dir->set('id', $id);

        // create the link from the new directory to this directory
        // if there is an error, mklink() will set it and cancel the transaction for us
        if(!$dir->mklink($this->getId(), $shortName, true))
            return null;

        // all is done, so we can push this transaction live
        SnapDBI::commitTransaction();

        // and save our new directory in the cache
        SnapCache::putById('Directory', $id, $dir);

        return $dir;
    }

    public function createResource($shortName, $contentType = SnapResource::TYPE_STDXML, $name = "", $description = "") {
        if(!$this->checkValid()) return false;

        if(!SnapDBI::startTransaction())
            return null;

        if($name == "")
            $name = $shortName;

        if($shortName === false || !$this->canCreateResource($shortName, $contentType)) {
            $this->setError('Cannot create resource because ' . $this->getReason());
            SnapDBI::cancelTransaction();
            return false;
        }

        $name = mysql_escape_string($name);
        $description = mysql_escape_string($description);

        $query = "INSERT INTO Resource (name, description, created, canonParentId, refCount, contentType, nextOrdinal) VALUES "
            . "('$name', '$description', CURRENT_TIMESTAMP, " . $this->getId() . ", 0, '$contentType', 1)";
        if(!SnapDBI::query($query)) {
            SnapDBI::cancelTransaction();
            return null;
        }
        $id = SnapDBI::getInsertId();

        if(!SnapResourceUserPermission::copy($this->getId(), $id) ||
            !SnapResourceGroupPermission::copy($this->getId(), $id))
        {
            SnapDBI::cancelTransaction();
            return null;
        }

        $res = new SnapResource();
        $res->set('id', $id);

        if(!$res->mklink($this->getId(), $shortName, true))
            return null;

        SnapDBI::commitTransaction();

        SnapCache::putById('Resource', $id, $res);

        return $res;
    }

    public function listContents($constraint = array(), $limit = array(), $order = array(), $count = false) {
        if(!$this->checkValid()) return false;

        $canonPath = $this->getCanonicalPath();

        if(!$count) {
            // since Resource has more columns than Directory, and we are doing a UNION query below we
            // have to make sure that both of the UNIONed SELECT statements select the same number of
            // elements; to do this, we add some (SELECT) NULL AS colName items to the directory SELECT;
            // we build that list here
            $numNulls = count(SnapResource::$ATTRIBUTES);
            $nulls = "";
            // start at the number of attributes directories already have and add nulls until we count
            // up to the number of attributes resources have
            for($i = count(self::$ATTRIBUTES); $i < $numNulls; $i++)
                $nulls .= "NULL AS " . SnapResource::$ATTRIBUTES[$i] . ',';
            $nulls = rtrim($nulls, ',');
        }

        if($count) {
            $dirAttrs = 'COUNT(*) AS dirCount, NULL AS resCount';
            $resAttrs = 'NULL AS dirCount, COUNT(*) AS resCount';
        }
        else {
            $dirAttrs = implode(',', array('parentId', 'childId', 'shortName', 'ordinal'))
                            . ',' . implode(',', self::$ATTRIBUTES) . ',' . $nulls;
            $resAttrs = implode(',', array('parentId', 'childId', 'shortName', 'ordinal'))
                            . ',' . implode(',', SnapResource::$ATTRIBUTES);
        }

        // I apologize for this crazy query, but it really works!
        //   also, the SELECT * is okay because it is selecting from a subselect where the fields are
        //   explicitly named
        if($count) {
            $query = 'SELECT * FROM (SELECT ' . $dirAttrs
                . ',\'Directory\' AS fileType FROM Directory '
                . 'LEFT JOIN DirectoryLink ON DirectoryLink.childId = Directory.id '
                . 'WHERE DirectoryLink.parentId = ' . $this->getId()
                . ' AND DirectoryLink.parentId <> DirectoryLink.childId '
                . 'UNION SELECT ' . $resAttrs . ',\'Resource\' AS fileType FROM Resource '
                . 'LEFT JOIN ResourceLink ON ResourceLink.childId = Resource.id '
                . 'WHERE ResourceLink.parentId = ' . $this->getId() . ') AS t1 ';
        }
        else {
            $query = 'SELECT * FROM (SELECT ' . $dirAttrs
                . ',\'Directory\' AS fileType, path FROM Directory '
                . 'LEFT JOIN DirectoryLink ON DirectoryLink.childId = Directory.id '
                . 'LEFT JOIN PathCache ON PathCache.directoryId = Directory.id '
                . 'WHERE DirectoryLink.parentId = ' . $this->getId()
                . ' AND DirectoryLink.parentId <> DirectoryLink.childId GROUP BY Directory.id '
                . 'UNION SELECT ' . $resAttrs . ',\'Resource\' AS fileType, path FROM Resource '
                . 'LEFT JOIN ResourceLink ON ResourceLink.childId = Resource.id '
                . 'LEFT JOIN PathCache ON PathCache.resourceId = Resource.id '
                . 'WHERE ResourceLink.parentId = ' . $this->getId() . ' GROUP BY Resource.id) AS t1 ';
        }

        $validAttrs = array_merge(self::$ATTRIBUTES, SnapResource::$ATTRIBUTES,
                                    array('parentId', 'childId', 'shortName', 'ordinal', 'fileType'));

        // these methods convert the constraint arrays to various clauses
        $where = SnapDBI::criteriaToString($constraint, $validAttrs);
        if($where === false) return null;
        else if($where != '') $query .= ' WHERE ' . $where;

        if(!$count) {
            $order = SnapDBI::orderToString($order, $validAttrs);
            if($order === false) return null;
            else if($order != '') $query .= ' ' . $order;

            $limit = SnapDBI::limitToString($limit);
            if($limit === false) return null;
            else if($limit != '') $query .= ' ' . $limit;
        }

        if(!SnapDBI::query($query)) {
            print_r(SnapDBI::getStaticError());
            $this->setError("Invalid query");
            return null;
        }

        if($count) {
            $dirCount = 0;
            $resCount = 0;
            while($row = SnapDBI::getRow()) {
                if($row['fileType'] == 'Directory')
                    $dirCount = $row['dirCount'];
                else
                    $resCount = $row['resCount'];
            }
            SnapDBI::freeResult();
            $res = array('directories' => $dirCount, 'resources' => $resCount);
            return $res;
        }

        $ret = array();
        while($row = SnapDBI::getRow()) {
            if($row['fileType'] == 'Directory') {
                $obj = SnapCache::getById('Directory', $row['id']);
                if($obj == null) {
                    $obj = new SnapDirectory();
                    foreach(self::$ATTRIBUTES as $a)
                        $obj->set($a, $row[$a]);
                    SnapCache::putById('Directory', $row['id'], $obj);
                    SnapCache::putByPath('Directory', $canonPath . $row['shortName'] . '/', $obj);
                }
            }
            else if($row['fileType'] == 'Resource') {
                $obj = SnapCache::getById('Resource', $row['id']);
                if($obj == null) {
                    $obj = new SnapResource();
                    foreach(SnapResource::$ATTRIBUTES as $a)
                        $obj->set($a, $row[$a]);
                                SnapCache::putById('Resource', $row['id'], $obj);
                    SnapCache::putByPath('Resource', $canonPath . $row['shortName'], $obj);
                }
            }
            $ret[] = $obj;
        }
        SnapDBI::freeResult();

        SnapPermissionCache::warmCache('Directory', $this->getId(), 'Directory');
        SnapPermissionCache::warmCache('Directory', $this->getId(), 'Resource');

        return $ret;
    }

    public function countContents($constraint = array(), $limit = array(), $order = array()) {
        return $this->listContents($constraint, $limit, $order, true);
/*
        if(!$this->checkValid()) return false;

        $numNulls = count(SnapResource::$ATTRIBUTES);
        $nulls = "";
        for($i = count(self::$ATTRIBUTES); $i < $numNulls; $i++)
            $nulls .= "NULL AS " . SnapResource::$ATTRIBUTES[$i] . ',';
        $nulls = rtrim($nulls, ',');

        // I apologize for this crazy query, but it really works!
        //   also, the SELECT * is okay because it is selecting from a subselect where the fields are
        //   explicitly named
        $query = 'SELECT COUNT(*) FROM (SELECT ' . implode(',', array('parentId', 'childId', 'shortName', 'ordinal'))
            . ',' . implode(',', self::$ATTRIBUTES) . ',' . $nulls
            . ',\'Directory\' AS fileType FROM Directory '
            . 'LEFT JOIN DirectoryLink ON DirectoryLink.childId = Directory.id '
            . 'WHERE DirectoryLink.parentId = ' . $this->getId()
            . ' AND DirectoryLink.parentId <> DirectoryLink.childId '
            . 'UNION SELECT ' . implode(',', array('parentId', 'childId', 'shortName', 'ordinal'))
            . ',' . implode(',', SnapResource::$ATTRIBUTES)
            . ',\'Resource\' AS fileType FROM Resource '
            . 'LEFT JOIN ResourceLink ON ResourceLink.childId = Resource.id '
            . 'WHERE ResourceLink.parentId = ' . $this->getId() . ') AS t1 ';

        $validAttrs = array_merge(self::$ATTRIBUTES, SnapResource::$ATTRIBUTES,
                                    array('parentId', 'childId', 'shortName', 'ordinal', 'fileType'));

        $where = SnapDBI::criteriaToString($constraint, $validAttrs);
        if($where === false) return null;
        else if($where != '') $query .= ' WHERE ' . $where;

        $order = SnapDBI::orderToString($order, $validAttrs);
        if($order === false) return null;
        else if($order != '') $query .= ' ' . $order;

        $limit = SnapDBI::limitToString($limit);
        if($limit === false) return null;
        else if($limit != '') $query .= ' ' . $limit;

        if(!SnapDBI::query($query)) {
            $this->setError("Invalid query");
            return null;
        }

        $cnt = SnapDBI::firstRow();
        SnapDBI::freeResult();
        return $cnt['COUNT(*)'];
 */
    }
}

?>

---