class.ilStartingPoint.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2017 ILIAS open source, Extended GPL, see docs/LICENSE */
 
class ilStartingPoint
{
    //list view: first and last items in the table are fixed.
    const ORDER_POSITION_MIN = 0;
    const ORDER_POSITION_MAX = 9999;
 
    //rule options.
    const FALLBACK_RULE = 1;
    const ROLE_BASED = 2;
    const USER_SELECTION_RULE = 3;
 
    protected $starting_point;
    protected $starting_object;
    protected $starting_position;
    protected $rule_type;
    protected $rule_options; // array serialized in db
    protected $id;
 
    public function __construct($a_id = 0)
    {
        if ($a_id > 0) {
            $this->id = $a_id;
            $this->setData($a_id);
        }
    }
 
    private function setData($a_id)
    {
        global $ilDB;
 
        $query = "SELECT * FROM usr_starting_point WHERE id = " . $ilDB->quote($a_id, 'integer');
        $res = $ilDB->query($query);
 
        while ($point = $ilDB->fetchAssoc($res)) {
            $this->setStartingPoint($point['starting_point']);
            $this->setRuleOptions($point['rule_options']);
            $this->setPosition($point['position']);
            $this->setStartingObject($point['starting_object']);
            $this->setRuleType($point['rule_type']);
        }
    }
 
    public function setStartingPoint($a_starting_point)
    {
        $this->starting_point = $a_starting_point;
    }
 
    public function getStartingPoint()
    {
        return $this->starting_point;
    }
 
    public function setStartingObject($a_starting_object)
    {
        $this->starting_object = $a_starting_object;
    }
 
    public function getStartingObject()
    {
        return $this->starting_object;
    }
 
    public function setPosition($a_starting_position)
    {
        $this->starting_position = $a_starting_position;
    }
 
    public function getPosition()
    {
        return $this->starting_position;
    }
 
    public function setRuleType($a_rule_type)
    {
        $this->rule_type = $a_rule_type;
    }
 
    public function getRuleType()
    {
        return $this->rule_type;
    }
 
    public function setRuleOptions($a_rule_options)
    {
        $this->rule_options = $a_rule_options;
    }
 
 
    public function getRuleOptions()
    {
        return $this->rule_options;
    }
 
    public static function getStartingPoints()
    {
        global $ilDB;
 
        $query = "SELECT * FROM usr_starting_point";
        $res = $ilDB->query($query);
        $points = array();
        while ($point = $ilDB->fetchAssoc($res)) {
            $points[] = array(
                "id" => $point["id"],
                "position" => $point["position"],
                "starting_point" => $point['starting_point'],
                "starting_object" => $point['starting_object'],
                "rule_type" => $point['rule_type'],
                "rule_options" => $point['rule_options']
            );
        }
 
        return $points;
    }
 
    public static function getRolesWithStartingPoint()
    {
        global $ilDB;
 
        $query = "SELECT * FROM usr_starting_point WHERE rule_options LIKE %s";
        $res = $ilDB->queryF($query, array('text'), array("%role_id%"));
 
        $roles = array();
        while ($sp = $ilDB->fetchAssoc($res)) {
            $options = unserialize($sp['rule_options']);
 
            $roles[$options['role_id']] = array(
                "id" => $sp['id'],
                "starting_point" => $sp['starting_point'],
                "starting_object" => $sp['starting_object'],
                "position" => $sp['position'],
                "role_id" => $options['role_id'],
 
            );
        }
        return $roles;
    }
 
    public static function getGlobalRolesWithoutStartingPoint()
    {
        global $rbacreview;
 
        require_once "./Services/AccessControl/classes/class.ilObjRole.php";
 
        $global_roles = $rbacreview->getGlobalRoles();
 
        $roles_with_starting_point = self::getRolesWithStartingPoint();
 
        $ids_roles_with_sp = array();
        foreach ($roles_with_starting_point as $role) {
            array_push($ids_roles_with_sp, $role['role_id']);
        }
 
        $ids_roles_without_sp = array_diff($global_roles, $ids_roles_with_sp);
 
        $roles = array();
        foreach ($ids_roles_without_sp as $roleid) {
            $role_obj = new ilObjRole($roleid);
            $roles[] = array(
                "id" => $role_obj->getId(),
                "title" => $role_obj->getTitle(),
            );
        }
 
        return $roles;
    }
 
    public function save()
    {
        global $ilDB;
 
        //get position
        $max_position = $this->getMaxPosition();
        $position = $max_position + 10;
 
        $next_id = $ilDB->nextId('usr_starting_point');
        $values = array(
                    $next_id,
                    $this->getStartingPoint(),
                    $this->getStartingObject(),
                    $position,
                    $this->getRuleType(),
                    $this->getRuleOptions()
                );
 
        $ilDB->manipulateF(
            "INSERT INTO usr_starting_point (id, starting_point, starting_object, position, rule_type, rule_options) VALUES (%s, %s, %s, %s, %s, %s)",
            array('integer', 'integer', 'integer', 'integer', 'integer', 'text'),
            $values
        );
    }
 
    public function update()
    {
        global $ilDB;
 
        $ilDB->manipulateF(
            'UPDATE usr_starting_point
                        SET starting_point = %s,
                                starting_object = %s,
                                position = %s,
                                rule_type = %s,
                                rule_options = %s
                        WHERE id = %s',
            array('integer', 'integer', 'integer', 'integer', 'text', 'integer'),
            array($this->getStartingPoint(), $this->getStartingObject(), $this->getPosition(),
                    $this->getRuleType(), $this->getRuleOptions(), $this->id)
        );
    }
 
    public function delete()
    {
        global $ilDB;
 
        $query = "DELETE FROM usr_starting_point WHERE id = " . $ilDB->quote($this->id, "integer");
        $ilDB->manipulate($query);
    }
 
    //Order methods
    public function getMaxPosition()
    {
        global $ilDB;
 
        //get max order number
        $result = $ilDB->query("SELECT max(position) as max_order FROM usr_starting_point");
 
        while ($row = $ilDB->fetchAssoc($result)) {
            $order_val = (int) $row['max_order'];
        }
        return $order_val;
    }
 
    public static function reArrangePositions($a_items)
    {
        //first and last items doesn't have order position, are fixed.
        $ord_const = 10;
        foreach ($a_items as $k => $v) {
            if ($k > 0) {
                $item = $v;
                $item['starting_position'] = $ord_const;
                unset($a_items[$k]);
                $a_items[$ord_const] = $item;
                $ord_const = $ord_const + 10;
            }
        }
 
        return $a_items;
    }
 
    public function saveOrder($a_items)
    {
        global $ilDB;
 
        asort($a_items);
        $nr = 10;
        foreach ($a_items as $id => $position) {
            if ($position > self::ORDER_POSITION_MIN && $position < self::ORDER_POSITION_MAX) {
                $ilDB->manipulate(
                    "UPDATE usr_starting_point SET" .
                    " position = " . $ilDB->quote($nr, 'integer') .
                    " WHERE id = " . $ilDB->quote($id, 'integer')
                );
                $nr+=10;
            }
        }
    }
}