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 
{
        var $refId;
        
        var $obj;

        var $isDebug = false;
        
        function ilObjectDAV($refId, $obj = null) 
        {
                if (is_object($obj))
                {
                        $this->writelog('<constructor>('.$refId.','.get_class($obj).')');
                }
                $this->refId = $refId;
                $this->obj =& $obj;
        }
        
        
        function getRefId()
        {
                return $this->refId;
        }
        function getObjectId()
        {
                return ($this->obj == null) ? null : $this->obj->getId();
        }
        
        function getNodeId()
        {
                return 0;
        }
        
        function initFromNull()
        {
                $this->obj->setPermissions($this->getRefId());
        }
        
        
        
        
        function read()
        {
                global $ilias;
                
                if (is_null($this->obj))
                {
                        $this->obj =& $ilias->obj_factory->getInstanceByRefId($this->getRefId());
                        $this->obj->read();
                }
        }
        function write()
        {
                $this->writelog('write() refid='.$this->refId);
                $this->obj->update();
        }
        
        
        function getResourceName()
        {
                return $this->obj->getUntranslatedTitle();
        }
        function setResourceName($name)
        {
                $this->writelog('setResourceName('.$name.')');
                return $this->obj->setTitle($name);
        }
        function getDisplayName()
        {
                return $this->obj->getTitle();
        }
        
        function getCreationTimestamp()
        {
                return strtotime($this->obj->getCreateDate());
        }
        
        function getModificationTimestamp()
        {
                return strtotime($this->obj->getLastUpdateDate());
        }
        
        function getResourceType()
        {
                return "";
        }
        
        function isCollection()
        {
                return $this->getResourceType() == 'collection';
        }
        function isFile()
        {
                return $this->getResourceType() == '';
        }
        function isNullResource()
        {
                return $this->getResourceType() == 'null';
        }
        
        function getContentType()
        {
                return 'application/x-non-readable';//'application/octet-stream';
        }
        function setContentType($type)
        {
                // subclass responsibility
        }
        function setContentLength($length)
        {
                // subclass responsibility
        }
        function getContentLength()
        {
                return 0;
        }
        function getContentStream()
        {
                return null;
        }
        function getContentOutputStream()
        {
                return null;
        }
        function getContentOutputStreamLength()
        {
                // subclass responsibility
        }
        function getContentData()
        {
                return null;
        }
        
        function isOnline()
        {
                return true;
        }
        
        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 $rbacsystem;
                        return $rbacsystem->checkAccess($operations, $this->getRefId(), $type);
                }
                else            // this one fixes bug #5367
                {
                        $GLOBALS['ilLog']->write('Checking permission for ref_id: '.$this->getRefId());
                        $GLOBALS['ilLog']->write("Operations: ".print_r($operations,true));
                        
                        global $ilAccess;
                        $operations = explode(",",$operations."");
                        foreach ($operations as $operation)
                        {
                                if (!$ilAccess->checkAccess($operation, '', $this->getRefId(), $type))
                                {
                                        $GLOBALS['ilLog']->write(__METHOD__.': Permission denied for user '.$GLOBALS['ilUser']->getId());
                                        return false;
                                }
                        }
                        return true;
                }
        }
        
        function getILIASType()
        {
                if($this->obj instanceof ilObject)
                {
                        return $this->obj->getType();
                }
                $GLOBALS['ilLog']->write(__METHOD__.': Invalid object given, class='.get_class($this->obj));
                $GLOBALS['ilLog']->logStack();
        }
        function getILIASCollectionType()
        {
                return 'fold';
        }
        function getILIASFileType()
        {
                return 'file';
        }

        function createNewVersion() {
        }

        
        function createCollection($name)
        {
                global $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);
        }
        function createFile($name)
        {
                global $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;
        }
        function createFileFromNull($name, &$nullDAV)
        {
                global $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;
        }
        function createNull($name)
        {
                global $tree;

                // create and insert Folder in tree
                require_once '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;
        }
        
        
        
        function remove($objDAV)
        {
                global $tree, $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()));
        }
        
        function addCopy(&$objDAV, $newName = null)
        {
                $this->writelog("addCopy($objDAV,$newName) ....");
                global $rbacadmin, $tree;
                $revIdMapping = array(); 
                $newRef = $this->cloneNodes($objDAV->getRefId(),$this->getRefId(),$revIdMapping, $newName);
                //$rbacadmin->adjustMovedObjectPermissions($newRef, $tree->getParentId($objDAV->getRefId()));
                return $this->createObject($newRef, $objDAV->getILIASType());
                $this->writelog('... addCopy done.');
        }

        function cloneNodes($srcRef,$dstRef,&$mapping, $newName=null)
        {
                $this->writelog("cloneNodes($srcRef,$dstRef,$mapping,$newName)");
                global $tree;
                global $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 = $this->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;
        }
        
        function addMove(&$objDAV, $newName = null)
        {
                global $tree;
                global $rbacadmin;
                global $ilias;
                global $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');
                */
        }
        
        function removeDeletedNodes($a_node_id, $a_checked, $a_delete_objects = true)
        {
                global $ilDB, $log, $ilias, $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;
        }
        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 $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 =& $this->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;
        }
        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;
        }
                
        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;
        }
        function writelog($message) 
        {
                if ($this->isDebug)
                {
                        global $log, $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);            
                        */
                }
        }

        function __toString() {
                return get_class($this).'#'.$this->getObjectId();
        }
}
// END WebDAV
?>