class.ilSCTreeTasks.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilSCTreeTasks
{
    private $db = null;
    private $task = null;
    
    public function __construct(ilSCTask $task)
    {
        $this->db = $GLOBALS['ilDB'];
        $this->task = $task;
    }
    
    
    public static function findDeepestDuplicate()
    {
        global $ilDB;
        
        $query = 'SELECT child FROM tree first  ' .
                'WHERE EXISTS ( ' .
                'SELECT child FROM tree second WHERE first.child = second.child ' .
                'GROUP BY child HAVING COUNT(child)  >  1 ) ' .
                'ORDER BY depth DESC';
        
        $GLOBALS['ilLog']->write($query);
        
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            return $row->child;
        }
        return 0;
    }
    
    public static function repairPK()
    {
        #$GLOBALS['ilDB']->dropPrimaryKey('tree');
        $GLOBALS['ilDB']->addPrimaryKey('tree', array('child'));
    }
    
    public static function getNodeInfo($a_tree_id, $a_child)
    {
        global $ilDB;
        
        $query = 'SELECT * FROM tree WHERE child = ' . $ilDB->quote($a_child, 'integer') . ' AND tree = ' . $ilDB->quote($a_tree_id, 'integer');
        $res = $ilDB->query($query);
 
        $node = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $node['child'] = $row->child;
            $node['tree'] = $row->tree;
            $node['depth'] = $row->depth;
            
            // read obj_id
            $query = 'SELECT obj_id FROM object_reference WHERE ref_id = ' . $ilDB->quote($a_child, 'integer');
            $ref_res = $ilDB->query($query);
            while ($ref_row = $ref_res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                $node['obj_id'] = $ref_row->obj_id;
                
                // read object info
                $query = 'SELECT title, description, type FROM object_data ' .
                        'WHERE obj_id = ' . $ilDB->quote($ref_row->obj_id);
                $obj_res = $ilDB->query($query);
                while ($obj_row = $obj_res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                    $node['title'] = $obj_row->title;
                    $node['description'] = $obj_row->description;
                    $node['type'] = $obj_row->type;
                }
            }
        }
        return $node;
    }
    
    public static function getChilds($a_tree_id, $a_childs)
    {
        global $ilDB;
        
        $query = 'SELECT * FROM tree WHERE tree = ' . $ilDB->quote($a_tree_id, 'integer') . ' ' . 'AND child = ' . $ilDB->quote($a_childs, 'integer');
        $res = $ilDB->query($query);
        
        $childs = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $childs[] = $row->child;
        }
        return $childs;
    }
    
    public static function findDuplicates($a_duplicate_id)
    {
        global $ilDB;
        
        $query = 'SELECT * FROM tree first  ' .
                'WHERE EXISTS ( ' .
                'SELECT child FROM tree second WHERE first.child = second.child ' .
                'GROUP BY child HAVING COUNT(child)  >  1 ) ' .
                'AND child = ' . $ilDB->quote($a_duplicate_id, 'integer') . ' ' .
                'ORDER BY depth DESC';
        $res = $ilDB->query($query);
        
        $GLOBALS['ilLog']->write($query);
        
        $nodes = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $node = array();
            $node['tree'] = $row->tree;
            $node['child'] = $row->child;
            $node['depth'] = $row->depth;
            
            $nodes[] = $node;
        }
        
        return $nodes;
    }
    
    public static function hasDuplicate($a_child)
    {
        global $ilDB;
        
        return count(self::findDuplicates($a_child));
    }
    
    public static function deleteDuplicateFromTree($a_duplicate_id, $a_delete_trash)
    {
        $dups = self::findDuplicates($a_duplicate_id);
        foreach ($dups as $dup) {
            if ($a_delete_trash and $dup['tree'] < 1) {
                self::deleteDuplicate($dup['tree'], $dup['child']);
            }
            if (!$a_delete_trash and $dup['tree'] == 1) {
                self::deleteDuplicate($dup['tree'], $dup['child']);
            }
        }
        return true;
    }
    
    protected static function deleteDuplicate($tree_id, $dup_id)
    {
        global $ilDB;
        
        $query = 'SELECT child FROM tree ' .
                'WHERE parent = ' . $ilDB->quote($dup_id, 'integer') . ' ' .
                'AND tree = ' . $ilDB->quote($tree_id, 'integer');
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            // start recursion
            self::deleteDuplicate($tree_id, $row->child);
        }
        // now delete node
        if (self::hasDuplicate($dup_id)) {
            $query = 'DELETE FROM tree ' .
                    'WHERE child = ' . $ilDB->quote($dup_id, 'integer') . ' ' .
                    'AND tree = ' . $ilDB->quote($tree_id, 'integer');
            $ilDB->manipulate($query);
        }
    }
 
 
    public function getDB()
    {
        return $this->db;
    }
    
    public function getTask()
    {
        return $this->task;
    }
    
    
    
    public function validateStructure()
    {
        $failures = $this->checkStructure();
        
        if (count($failures)) {
            $this->getTask()->setStatus(ilSCTask::STATUS_FAILED);
        } else {
            $this->getTask()->setStatus(ilSCTask::STATUS_COMPLETED);
        }
        $this->getTask()->setLastUpdate(new ilDateTime(time(), IL_CAL_UNIX));
        $this->getTask()->update();
        return count($failures);
    }
    
    
    public function checkStructure()
    {
        return $GLOBALS['tree']->validateParentRelations();
        global $ilDB;
        
        $query = 'select child from tree child where not exists ' .
                '( ' .
                'select child from tree parent where child.parent = parent.child and (parent.lft < child.lft) and (parent.rgt > child.rgt) ' .
                ')' .
                'and tree = 1 and child <> 1';
        $res = $ilDB->query($query);
        
        $failures = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $failures[] = $row->child;
        }
        return $failures;
    }
    
    
    
    public function validateDuplicates()
    {
        $failures = $this->checkDuplicates();
        
        if (count($failures)) {
            $this->getTask()->setStatus(ilSCTask::STATUS_FAILED);
        } else {
            $this->getTask()->setStatus(ilSCTask::STATUS_COMPLETED);
        }
        $this->getTask()->setLastUpdate(new ilDateTime(time(), IL_CAL_UNIX));
        $this->getTask()->update();
        return count($failures);
    }
    
    public function checkDuplicates()
    {
        $query = 'SELECT child, count(child) num FROM tree ' .
                'GROUP BY child ' .
                'HAVING count(child) > 1';
        $res = $this->getDB()->query($query);
        
        $GLOBALS['ilLog']->write($query);
        
        $failures = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $failures[] = $row->child;
        }
        return $failures;
    }
    
    public function findMissingTreeEntries()
    {
        global $ilDB;
        
        $failures = $this->readMissingTreeEntries();
        
        if (count($failures)) {
            $this->getTask()->setStatus(ilSCTask::STATUS_FAILED);
        } else {
            $this->getTask()->setStatus(ilSCTask::STATUS_COMPLETED);
        }
        
        $this->getTask()->setLastUpdate(new ilDateTime(time(), IL_CAL_UNIX));
        $this->getTask()->update();
        return count($failures);
    }
    
    
    public function findMissing()
    {
        global $ilDB;
        
        $failures = $this->readMissing();
        
        if (count($failures)) {
            $this->getTask()->setStatus(ilSCTask::STATUS_FAILED);
        } else {
            $this->getTask()->setStatus(ilSCTask::STATUS_COMPLETED);
        }
        
        $this->getTask()->setLastUpdate(new ilDateTime(time(), IL_CAL_UNIX));
        $this->getTask()->update();
        return count($failures);
    }
    
    public function repairMissing()
    {
        $failures = $this->readMissing();
        $recf_ref_id = $this->createRecoveryContainer();
        foreach ($failures as $ref_id) {
            $this->repairMissingObject($recf_ref_id, $ref_id);
        }
    }
    
    protected function repairMissingObject($a_parent_ref, $a_ref_id)
    {
        global $ilDB;
        
        // check if object entry exist
        $query = 'SELECT obj_id FROM object_reference ' .
                'WHERE ref_id = ' . $ilDB->quote($a_ref_id, 'integer');
        
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $query = 'SELECT type, title FROM object_data ' .
                    'WHERE obj_id = ' . $ilDB->quote($row->obj_id, 'integer');
            $ores = $ilDB->query($query);
            
            $done = false;
            while ($orow = $ores->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                $GLOBALS['ilLog']->write(__METHOD__ . ': Moving to recovery folder: ' . $orow->type . ': ' . $orow->title);
                $done = true;
                
                include_once './Services/Object/classes/class.ilObjectFactory.php';
                $factory = new ilObjectFactory();
                $ref_obj = $factory->getInstanceByRefId($a_ref_id, false);
                
                if ($ref_obj instanceof ilObjRoleFolder) {
                    $ref_obj->delete();
                } elseif ($ref_obj instanceof ilObject) {
                    $ref_obj->putInTree($a_parent_ref);
                    $ref_obj->setPermissions($a_parent_ref);
                    $GLOBALS['ilLog']->write(__METHOD__ . ': Moving finished');
                    break;
                }
            }
            if (!$done) {
                // delete reference value
                $query = 'DELETE FROM object_reference WHERE ref_id = ' . $ilDB->quote($a_ref_id, 'integer');
                $ilDB->manipulate($query);
                $GLOBALS['ilLog']->write(__METHOD__ . ': Delete reference for "object" without tree and object_data entry: ref_id= ' . $a_ref_id);
            }
        }
    }
 
    protected function readMissing()
    {
        global $ilDB;
        
        $query = 'SELECT ref_id FROM object_reference ' .
                'LEFT JOIN tree ON ref_id = child ' .
                'WHERE child IS NULL';
        $res = $ilDB->query($query);
        
        $failures = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $failures[] = $row->ref_id;
        }
        return $failures;
    }
    
    public function repairMissingTreeEntries()
    {
        global $ilDB;
        
        $missing = $this->readMissingTreeEntries();
        $GLOBALS['ilLog']->write(__METHOD__ . ': ' . print_r($missing, true));
        
        foreach ($missing as $ref_id) {
            // check for duplicates
            $query = 'SELECT tree, child FROM tree ' .
                    'WHERE child = ' . $ilDB->quote($ref_id);
            $res = $ilDB->query($query);
            while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                $GLOBALS['ilLog']->write(__METHOD__ . ': ' . $row->tree . ': ' . $ref_id);
                
                $this->deleteMissingTreeEntry($row->tree, $ref_id);
            }
        }
    }
    
    protected function deleteMissingTreeEntry($a_tree_id, $a_ref_id)
    {
        global $ilDB;
        
        $query = 'SELECT child FROM tree ' .
                'WHERE parent = ' . $ilDB->quote($a_ref_id, 'integer') . ' ' .
                'AND tree = ' . $ilDB->quote($a_tree_id, 'integer');
 
        $res = $ilDB->query($query);
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            // check for duplicates
            $query = 'SELECT tree, child FROM tree ' .
                    'WHERE child = ' . $ilDB->quote($row->child);
            $resd = $ilDB->query($query);
            while ($rowd = $resd->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
                $this->deleteMissingTreeEntry($rowd->tree, $rowd->child);
            }
        }
        
        // finally delete
        include_once './Services/Object/classes/class.ilObjectFactory.php';
        $factory = new ilObjectFactory();
        $ref_obj = $factory->getInstanceByRefId($a_ref_id, false);
                
        if (($ref_obj instanceof ilObject) and $ref_obj->getType()) {
            $ref_obj->delete();
        }
        
        $query = 'DELETE from tree ' .
                'WHERE tree = ' . $ilDB->quote($a_tree_id) . ' ' .
                'AND child = ' . $ilDB->quote($a_ref_id);
        $ilDB->manipulate($query);
    }
    
    
    protected function readMissingTreeEntries()
    {
        global $ilDB;
        
        $query = 'SELECT child FROM tree ' .
                'LEFT JOIN object_reference ON child = ref_id ' .
                'WHERE ref_id IS NULL';
        
        $res = $ilDB->query($query);
        
        $failures = array();
        while ($row = $res->fetchRow(ilDBConstants::FETCHMODE_OBJECT)) {
            $failures[] = $row->child;
        }
        return $failures;
    }
    
    
    protected function createRecoveryContainer()
    {
        $now = new ilDateTime(time(), IL_CAL_UNIX);
        
        include_once './Modules/Folder/classes/class.ilObjFolder.php';
        $folder = new ilObjFolder();
        $folder->setTitle('__System check recovery: ' . $now->get(IL_CAL_DATETIME));
        $folder->create();
        $folder->createReference();
        $folder->putInTree(RECOVERY_FOLDER_ID);
        
        return $folder->getRefId();
    }
}