class.ilObjectDAV.php

Go to the documentation of this file.

<?php
// BEGIN WebDAV
/*
    +-----------------------------------------------------------------------------+
    | ILIAS open source                                                           |
    +-----------------------------------------------------------------------------+
    | Copyright (c) 1998-2005 ILIAS open source, University of Cologne            |
    |                                                                             |
    | This program is free software; you can redistribute it and/or               |
    | modify it under the terms of the GNU General Public License                 |
    | as published by the Free Software Foundation; either version 2              |
    | of the License, or (at your option) any later version.                      |
    |                                                                             |
    | This program is distributed in the hope that it will be useful,             |
    | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
    | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
    | GNU General Public License for more details.                                |
    |                                                                             |
    | You should have received a copy of the GNU General Public License           |
    | along with this program; if not, write to the Free Software                 |
    | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
    +-----------------------------------------------------------------------------+
*/
 
class ilObjectDAV
{
    public $refId;
    
    public $obj;
 
    public $isDebug = false;
    
    public function __construct($refId, $obj = null)
    {
        if (is_object($obj)) {
            $this->writelog('<constructor>(' . $refId . ',' . get_class($obj) . ')');
        }
        $this->refId = $refId;
        $this->obj =&$obj;
    }
    
    
    public function getRefId()
    {
        return $this->refId;
    }
    public function getObjectId()
    {
        return ($this->obj == null) ? null : $this->obj->getId();
    }
    
    public function getNodeId()
    {
        return 0;
    }
    
    public function initFromNull()
    {
        $this->obj->setPermissions($this->getRefId());
    }
    
    
    
    
    public function read()
    {
        global $DIC;
        $ilias = $DIC['ilias'];
        
        if (is_null($this->obj)) {
            $this->obj =&$ilias->obj_factory->getInstanceByRefId($this->getRefId());
            $this->obj->read();
        }
    }
    public function write()
    {
        $this->writelog('write() refid=' . $this->refId);
        $this->obj->update();
    }
    
    
    public function getResourceName()
    {
        return $this->obj->getUntranslatedTitle();
    }
    public function setResourceName($name)
    {
        $this->writelog('setResourceName(' . $name . ')');
        return $this->obj->setTitle($name);
    }
    public function getDisplayName()
    {
        return $this->obj->getTitle();
    }
    
    public function getCreationTimestamp()
    {
        return strtotime($this->obj->getCreateDate());
    }
    
    public function getModificationTimestamp()
    {
        return strtotime($this->obj->getLastUpdateDate());
    }
    
    public function getResourceType()
    {
        return "";
    }
    
    public function isCollection()
    {
        return $this->getResourceType() == 'collection';
    }
    public function isFile()
    {
        return $this->getResourceType() == '';
    }
    public function isNullResource()
    {
        return $this->getResourceType() == 'null';
    }
        
    public function getContentType()
    {
        return 'application/x-non-readable';//'application/octet-stream';
    }
    public function setContentType($type)
    {
        // subclass responsibility
    }
    public function setContentLength($length)
    {
        // subclass responsibility
    }
    public function getContentLength()
    {
        return 0;
    }
    public function getContentStream()
    {
        return null;
    }
    public function getContentOutputStream()
    {
        return null;
    }
    public function getContentOutputStreamLength()
    {
        // subclass responsibility
    }
    public function getContentData()
    {
        return null;
    }
    
    public function isOnline()
    {
        return true;
    }
    
    public function isPermitted($operations, $type = '')
    {
        // Mount instructions are always visible
        if (isset($_GET['mount-instructions'])) {
            return true;
        }
        
        // The 'visible' operation is only permitted if the object is online,
        // or if the user is also permitted the perform the 'write' operation.
        if (false) {            // old implementation deactivated
            $ops = explode(',', $operations);
            if (in_array('visible', $ops) && !in_array('write', $ops)) {
                if (!$this->isOnline()) {
                    $operations .= ',write';
                }
            }
        
            global $DIC;
            $rbacsystem = $DIC['rbacsystem'];
            return $rbacsystem->checkAccess($operations, $this->getRefId(), $type);
        } else {                // this one fixes bug #5367
            $GLOBALS['DIC']['ilLog']->write('Checking permission for ref_id: ' . $this->getRefId());
            $GLOBALS['DIC']['ilLog']->write("Operations: " . print_r($operations, true));
            
            global $DIC;
            $ilAccess = $DIC['ilAccess'];
            $operations = explode(",", $operations . "");
            foreach ($operations as $operation) {
                if (!$ilAccess->checkAccess($operation, '', $this->getRefId(), $type)) {
                    $GLOBALS['DIC']['ilLog']->write(__METHOD__ . ': Permission denied for user ' . $GLOBALS['DIC']['ilUser']->getId());
                    return false;
                }
            }
            return true;
        }
    }
    
    public function getILIASType()
    {
        if ($this->obj instanceof ilObject) {
            return $this->obj->getType();
        }
        $GLOBALS['DIC']['ilLog']->write(__METHOD__ . ': Invalid object given, class=' . get_class($this->obj));
        $GLOBALS['DIC']['ilLog']->logStack();
    }
    public function getILIASCollectionType()
    {
        return 'fold';
    }
    public function getILIASFileType()
    {
        return 'file';
    }
 
    public function createNewVersion()
    {
    }
 
    
    public function createCollection($name)
    {
        global $DIC;
        $tree = $DIC['tree'];
 
        // create and insert Folder in tree
        require_once 'Modules/Folder/classes/class.ilObjFolder.php';
        $newObj = new ilObjFolder(0);
        $newObj->setType($this->getILIASCollectionType());
        $newObj->setTitle($name);
        //$newObj->setDescription('');
        $newObj->create();
        $newObj->createReference();
        $newObj->setPermissions($this->getRefId());
        $newObj->putInTree($this->getRefId());
        
        require_once 'class.ilObjFolderDAV.php';
        return new ilObjFolderDAV($newObj->getRefId(), $newObj);
    }
    public function createFile($name)
    {
        global $DIC;
        $tree = $DIC['tree'];
 
        // create and insert Folder in tree
        require_once 'Modules/File/classes/class.ilObjFile.php';
        $newObj = new ilObjFile(0);
        $newObj->setType($this->getILIASFileType());
        $newObj->setTitle($name);
        $newObj->setFileName($name);
        include_once("./Services/Utilities/classes/class.ilMimeTypeUtil.php");
        $mime = ilMimeTypeUtil::getMimeType("", $name, 'application/octet-stream');
        //$newObj->setFileType('application/octet-stream');
        $newObj->setFileType($mime);
        //$newObj->setDescription('');
        $newObj->create();
        $newObj->createReference();
        $newObj->setPermissions($this->getRefId());
        $newObj->putInTree($this->getRefId());
        //$newObj->createDirectory();
        
        require_once 'class.ilObjFileDAV.php';
        $objDAV = new ilObjFileDAV($newObj->getRefId(), $newObj);
        /*
        $fs = $objDAV->getContentOutputStream();
        fwrite($fs,' ');
        fclose($fs);
        */
        return $objDAV;
    }
    public function createFileFromNull($name, &$nullDAV)
    {
        global $DIC;
        $tree = $DIC['tree'];
 
        // create and insert Folder in tree
        require_once 'Modules/File/classes/class.ilObjFile.php';
        $objDAV =&$nullDAV->convertToILIASType($this->getRefId(), $this->getILIASFileType());
        $objDAV->initFromNull();
        return $objDAV;
    }
    public function createNull($name)
    {
        global $DIC;
        $tree = $DIC['tree'];
 
        // create and insert Folder in tree
        require_once './Services/Object/classes/class.ilObject.php';
        $newObj = new ilObject(0);
        $newObj->setType('null');
        $newObj->setTitle($name);
        $newObj->create();
        $newObj->createReference();
        $newObj->setPermissions($this->getRefId());
        $newObj->putInTree($this->getRefId());
        
        require_once 'class.ilObjNullDAV.php';
        $objDAV = new ilObjNullDAV($newObj->getRefId(), $newObj);
        
        return $objDAV;
    }
    
    
    
    public function remove($objDAV)
    {
        global $DIC;
        $tree = $DIC['tree'];
        $rbacadmin = $DIC['rbacadmin'];
        
        $subnodes = $tree->getSubTree($tree->getNodeData($objDAV->getRefId()));
        foreach ($subnodes as $node) {
            $rbacadmin->revokePermission($node["child"]);
            $affectedUsers = ilUtil::removeItemFromDesktops($node["child"]);
        }
        $tree->saveSubTree($objDAV->getRefId());
        $tree->deleteTree($tree->getNodeData($objDAV->getRefId()));
    }
    
    public function addCopy(&$objDAV, $newName = null)
    {
        $this->writelog("addCopy($objDAV,$newName) ....");
        global $DIC;
        $rbacadmin = $DIC['rbacadmin'];
        $tree = $DIC['tree'];
        $revIdMapping = array();
        $newRef = $this->cloneNodes($objDAV->getRefId(), $this->getRefId(), $revIdMapping, $newName);
        //$rbacadmin->adjustMovedObjectPermissions($newRef, $tree->getParentId($objDAV->getRefId()));
        return self::createObject($newRef, $objDAV->getILIASType());
        $this->writelog('... addCopy done.');
    }
 
    public function cloneNodes($srcRef, $dstRef, &$mapping, $newName=null)
    {
        $this->writelog("cloneNodes($srcRef,$dstRef,$mapping,$newName)");
        global $DIC;
        $tree = $DIC['tree'];
        global $DIC;
        $ilias = $DIC['ilias'];
        
        // clone the source node
        $srcObj =&$ilias->obj_factory->getInstanceByRefId($srcRef);
        $this->writelog('cloneNodes cloning srcRef=' . $srcRef . ' dstRef=' . $dstRef . '...');
        $newObj = $srcObj->cloneObject($dstRef);
        $newRef = $newObj->getRefId();
        
        // We must immediately apply a new name to the object, to
        // prevent confusion of WebDAV clients about having two objects with identical
        // name in the repository.
        $this->writelog("cloneNodes newname not null? " . (!is_null($newName)));
        if (!is_null($newName)) {
            $newObjDAV = self::createObject($newRef, $srcObj->getType());
            $newObjDAV->setResourceName($newName);
            $newObjDAV->write();
        }
        unset($srcObj);
        $mapping[$newRef] = $srcRef;
 
        // clone all children of the source node
        $children = $tree->getChilds($srcRef);
        foreach ($tree->getChilds($srcRef) as $child) {
            // Don't clone role folders, because it does not make sense to clone local roles
            // FIXME - Maybe it does make sense (?)
            if ($child["type"] != 'rolf') {
                $this->cloneNodes($child["ref_id"], $newRef, $mapping, null);
            } else {
                if (count($rolf = $tree->getChildsByType($newRef, "rolf"))) {
                    $mapping[$rolf[0]["ref_id"]] = $child["ref_id"];
                }
            }
        }
        $this->writelog('cloneNodes ...cloned srcRef=' . $srcRef . ' dstRef=' . $dstRef . ' newRef=' . $newRef);
        return $newRef;
    }
    
    public function addMove(&$objDAV, $newName = null)
    {
        global $DIC;
        $tree = $DIC['tree'];
        global $DIC;
        $rbacadmin = $DIC['rbacadmin'];
        global $DIC;
        $ilias = $DIC['ilias'];
        global $DIC;
        $log = $DIC['log'];
    
        $this->writelog('addMove(' . $objDAV->getRefId() . ' to ' . $this->getRefId() . ', newName=' . $newName . ')');
        
        // Step 0:Assign new name to moved object
        if (!is_null($newName)) {
            $objDAV->setResourceName($newName);
            $objDAV->write();
        }
        
        // Step 1: Store old parent
        $old_parent = $tree->getParentId($objDAV->getRefId());
        
        // Step 2: Move the tree
        $tree->moveTree($objDAV->getRefId(), $this->getRefId());
        
        // Step 3: Repair permissions
        $rbacadmin->adjustMovedObjectPermissions($objDAV->getRefId(), $old_parent);
        
        /*
        // STEP 1: Move subtree to trash
        $this->writelog('addMove('.$objDAV->getRefId().' to '.$this->getRefId().') step 1: move subtree to trash');
        $subnodes = $tree->getSubTree($tree->getNodeData($objDAV->getRefId()));
        foreach ($subnodes as $node)
        {
            $rbacadmin->revokePermission($node["child"]);
            $affectedUsers = ilUtil::removeItemFromDesktops($node["child"]);
        }
        $tree->saveSubTree($objDAV->getRefId());
        $tree->deleteTree($tree->getNodeData($objDAV->getRefId()));
 
        // STEP 2: Move subtree to new location
        // TODO: this whole put in place again stuff needs revision. Permission settings get lost.
        $this->writelog('addMove() step 2: move subtree to new location');
        // put top node to dest
        $rbacadmin->revokePermission($subnodes[0]['child']);
        $obj_data =& $ilias->obj_factory->getInstanceByRefId($subnodes[0]['child']);
        $obj_data->putInTree($this->getRefId());
        $obj_data->setPermissions($this->getRefId());
        array_shift($subnodes);
 
        // put all sub nodes to their parent (of which we have moved top already to dest).
        foreach ($subnodes as $node)
        {
            $rbacadmin->revokePermission($node['child']);
            $obj_data =& $ilias->obj_factory->getInstanceByRefId($node['child']);
            $obj_data->putInTree($node['parent']);
            $obj_data->setPermissions($node['parent']);
        }
 
        // STEP 3: Remove trashed objects from system
        $this->writelog('addMove('.$objDAV->getRefID().') step 3: remove trashed objects from system');
        require_once 'Services/Tree/classes/class.ilTree.php';
        $trashTree = new ilTree(- (int) $objDAV->getRefId());
        $node = $trashTree->getNodeData($objDAV->getRefId());
        $subnodes = $trashTree->getSubTree($node);
 
        // remember already checked deleted node_ids
        $checked[] = -(int) $objDAV->getRefId();
 
        // dive in recursive manner in each already deleted subtrees and remove these objects too
        $this->removeDeletedNodes($objDAV->getRefId(), $checked, false);
 
        // delete trash tree
        $tree->deleteTree($node);
        $this->writelog('addMove('.$objDAV->getRefID().') all 3 steps done');
        */
    }
    
    public function removeDeletedNodes($a_node_id, $a_checked, $a_delete_objects = true)
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        $log = $DIC['log'];
        $ilias = $DIC['ilias'];
        $tree = $DIC['tree'];
        
        $query = "SELECT tree FROM tree WHERE parent = ? AND tree < 0 ";
        $sta = $ilDB->prepare($query, array('integer','integer'));
        $res = $ilDB->execute($sta, array(
            $a_node_id,
            0));
        
 
        while ($row = $ilDB->fetchObject($res)) {
            // only continue recursion if fetched node wasn't touched already!
            if (!in_array($row->tree, $a_checked)) {
                $deleted_tree = new ilTree($row->tree);
                $a_checked[] = $row->tree;
 
                $row->tree = $row->tree * (-1);
                $del_node_data = $deleted_tree->getNodeData($row->tree);
                $del_subtree_nodes = $deleted_tree->getSubTree($del_node_data);
 
                $this->removeDeletedNodes($row->tree, $a_checked);
            
                if ($a_delete_objects) {
                    foreach ($del_subtree_nodes as $node) {
                        $node_obj =&$ilias->obj_factory->getInstanceByRefId($node["ref_id"]);
                        
                        // write log entry
                        /*$this->writelog("removeDeletedNodes(), delete obj_id: ".$node_obj->getId().
                            ", ref_id: ".$node_obj->getRefId().", type: ".$node_obj->getType().", ".
                            "title: ".$node_obj->getTitle());
                        */
                        $node_obj->delete();
                    }
                }
            
                $tree->deleteTree($del_node_data);
                
                // write log entry
                //$this->writelog("removeDeletedNodes(), deleted tree, tree_id: ".$del_node_data["tree"].", child: ".$del_node_data["child"]);
            }
        }
        
        return true;
    }
    public function children()
    {
        // FIXME: Remove duplicate entries from this list, because of RFC2518, chapter 5.2
        //        If a duplicate is found, the older object must win. We use the object
        //        id to determine this. This is based on the assumption, that new objects
        //        have higher object id's then older objects.
        
        global $DIC;
        $tree = $DIC['tree'];
        
        $childrenDAV = array();
        // Performance optimization. We sort the children using PHP instead of using the database.
        //$childrenData =& $tree->getChilds($this->getRefId(),'title');
        $childrenData =&$tree->getChilds($this->getRefId(), '');
        foreach ($childrenData as $data) {
            $childDAV =&self::createObject($data['ref_id'], $data['type']);
            if (!is_null($childDAV)) {
                // Note: We must not assign with =& here, because this will cause trouble
                //       when other functions attempt to work with the $childrenDAV array.
                $childrenDAV[] = $childDAV;
            }
        }
        return $childrenDAV;
    }
    public function childrenWithPermission($operations, $type  ='')
    {
        //$this->writelog('@'.$this->getRefId().'.childrenWithPermission('.$operations.','.$type.')');
        $childrenDAV = $this->children();
        $permittedChildrenDAV = array();
        foreach ($childrenDAV as $childDAV) {
            if ($childDAV->isPermitted($operations, $type)) {
                $permittedChildrenDAV[] = $childDAV;
            }
        }
        //$this->writelog('@'.$this->getRefId().'.childrenWithPermission():'.count($permittedChildrenDAV).' children');
        return $permittedChildrenDAV;
    }
        
    public static function createObject($refId, $type)
    {
        $newObj = null;
        
        switch ($type) {
            case 'mountPoint':
                require_once 'class.ilObjMountPointDAV.php';
                $newObj = new ilObjMountPointDAV($refId, null);
                break;
            case 'root':
                require_once 'class.ilObjRootDAV.php';
                $newObj = new ilObjRootDAV($refId, null);
                break;
            case 'cat':
                require_once 'class.ilObjCategoryDAV.php';
                $newObj = new ilObjCategoryDAV($refId, null);
                break;
            case 'fold':
                require_once 'class.ilObjFolderDAV.php';
                $newObj = new ilObjFolderDAV($refId, null);
                break;
            case 'crs':
                require_once 'class.ilObjCourseDAV.php';
                $newObj = new ilObjCourseDAV($refId, null);
                break;
            case 'grp':
                require_once 'class.ilObjGroupDAV.php';
                $newObj = new ilObjGroupDAV($refId, null);
                break;
            case 'file':
                require_once 'class.ilObjFileDAV.php';
                $newObj = new ilObjFileDAV($refId, null);
                break;
            case 'null':
                require_once 'class.ilObjNullDAV.php';
                $newObj = new ilObjNullDAV($refId, null);
                break;
            default:
                break;
        }
        if (!is_null($newObj)) {
            $newObj->read();
        }
        return $newObj;
    }
    public function writelog($message)
    {
        if ($this->isDebug) {
            global $DIC;
            $log = $DIC['log'];
            $ilias = $DIC['ilias'];
            $log->write(
                $ilias->account->getLogin()
                . ' DAV .' . get_class($this) . ' ' . str_replace("\n", ";", $message)
            );
            /*
            $fh = fopen('/opt/ilias/log/ilias.log', 'a');
            fwrite($fh, date('Y-m-d h:i:s '));
            fwrite($fh, str_replace("\n",";",$message));
            fwrite($fh, "\n\n");
            fclose($fh);
            */
        }
    }
 
    public function __toString()
    {
        return get_class($this) . '#' . $this->getObjectId();
    }
}
// END WebDAV