class.ilECSCategoryMappingRule.php

Go to the documentation of this file.

<?php
/*
    +-----------------------------------------------------------------------------+
    | ILIAS open source                                                           |
    +-----------------------------------------------------------------------------+
    | Copyright (c) 1998-2006 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. |
    +-----------------------------------------------------------------------------+
*/

include_once './Services/Calendar/classes/class.ilDate.php';

class ilECSCategoryMappingRule
{
    const ATTR_STRING = 1;
    const ATTR_INT = 2;
    const ATTR_ARRAY = 3;
    
    const TYPE_FIXED = 0;
    const TYPE_DURATION = 1;
    const TYPE_BY_TYPE = 2;
    
    const ERR_MISSING_VALUE = 'ecs_err_missing_value';
    const ERR_INVALID_DATES = 'ecs_err_invalid_dates';
    const ERR_INVALID_TYPE = 'ecs_err_invalid_type';
    const ERR_MISSING_BY_TYPE = 'ecs_err_invalid_by_type';
    
    protected $db;
    
    private $mapping_id;
    private $container_id;
    private $field_name;
    private $mapping_type;
    private $mapping_value;
    private $range_dt_start;
    private $range_dt_end;
    private $by_type;
    
    public function __construct($a_mapping_id = 0)
    {
        global $ilDB;
        
        $this->mapping_id = $a_mapping_id;
        
        $this->db = $ilDB;
        $this->read();
    }
    
    protected function setMappingId($a_id)
    {
        $this->mapping_id = $a_id;
    }
    
    public function getMappingId()
    {
        return $this->mapping_id;
    }
    
    public function setContainerId($a_id)
    {
        $this->container_id = $a_id;
    }
    
    public function getContainerId()
    {
        return $this->container_id;
    }
    
    public function setDateRangeStart($start)
    {
        $this->range_dt_start = $start;
    }
    
    public function getDateRangeStart()
    {
        return $this->range_dt_start ? $this->range_dt_start : new ilDate(time(), IL_CAL_UNIX);
    }
    
    public function setDateRangeEnd($end)
    {
        $this->range_dt_end = $end;
    }
    
    public function getDateRangeEnd()
    {
        if ($this->range_dt_end) {
            return $this->range_dt_end;
        }
        $this->range_dt_end = $this->getDateRangeStart();
        $this->range_dt_end->increment(IL_CAL_MONTH, 6);
        return $this->range_dt_end;
    }

    public function setFieldName($a_field)
    {
        $this->field_name = $a_field;
    }
    
    public function getFieldName()
    {
        return $this->field_name;
    }
    
    public function setMappingType($a_type)
    {
        $this->mapping_type = $a_type;
    }
    
    public function getMappingType()
    {
        return $this->mapping_type;
    }
    
    public function setMappingValue($a_value)
    {
        $this->mapping_value = $a_value;
    }
    
    public function getMappingValue()
    {
        return $this->mapping_value;
    }
    
    public function getMappingAsArray()
    {
        return explode(',', $this->getMappingValue());
    }
    
    public function setByType($a_type)
    {
        $this->by_type = $a_type;
    }
    
    public function getByType()
    {
        return $this->by_type;
    }
    
    public function delete()
    {
        $sta = $this->db->manipulateF(
            'DELETE FROM ecs_container_mapping WHERE mapping_id = %s ',
            array('integer'),
            array($this->getMappingId())
        );
    }
    
    public function update()
    {
        if ($this->getMappingType() == self::TYPE_BY_TYPE) {
            $mapping_value = $this->getByType();
        } else {
            $mapping_value = $this->getMappingValue();
        }
        
        $sta = $this->db->manipulateF(
            'UPDATE ecs_container_mapping SET ' .
            'container_id = %s, ' .
            'field_name = %s, ' .
            'mapping_type = %s, ' .
            'mapping_value = %s, ' .
            'date_range_start = %s,' .
            'date_range_end = %s ' .
            'WHERE mapping_id = %s',
            array('integer','text','integer','text','integer','integer','integer'),
            array(
            $this->getContainerId(),
            $this->getFieldName(),
            $this->getMappingType(),
            $mapping_value,
            $this->getDateRangeStart()->get(IL_CAL_UNIX),
            $this->getDateRangeEnd()->get(IL_CAL_UNIX),
            $this->getMappingId())
        );
    }
    
    public function save()
    {
        global $ilDB;
        
        if ($this->getMappingType() == self::TYPE_BY_TYPE) {
            $mapping_value = $this->getByType();
        } else {
            $mapping_value = $this->getMappingValue();
        }
        
        $mapping_id = $ilDB->nextId('ecs_container_mapping');
        $sta = $this->db->manipulateF(
            'INSERT INTO ecs_container_mapping  ' .
            '(mapping_id,container_id,field_name,mapping_type,mapping_value,date_range_start,date_range_end) ' .
            'VALUES(%s,%s,%s,%s,%s,%s,%s) ',
            array('integer','integer','text','integer','text','integer','integer'),
            array(
                $mapping_id,
                $this->getContainerId(),
                $this->getFieldName(),
                $this->getMappingType(),
                $mapping_value,
                $this->getDateRangeStart()->get(IL_CAL_UNIX),
                $this->getDateRangeEnd()->get(IL_CAL_UNIX))
        );
    }
    
    public function validate()
    {
        if (ilObject::_lookupType(ilObject::_lookupObjId($this->getContainerId())) != 'cat') {
            return self::ERR_INVALID_TYPE;
        }
        if (!ilDateTime::_after($this->getDateRangeEnd(), $this->getDateRangeStart(), IL_CAL_DAY)) {
            return self::ERR_INVALID_DATES;
        }
        if ($this->getMappingType() == self::TYPE_DURATION && !in_array($this->getFieldName(), array('begin', 'end'))) {
            return self::ERR_MISSING_VALUE;
        }
        // handled by form gui?
        if ($this->getMappingType() == self::TYPE_FIXED and !$this->getMappingValue()) {
            return self::ERR_MISSING_VALUE;
        }
        if ($this->getMappingType() == self::TYPE_BY_TYPE && $this->getFieldName() != 'type') {
            return self::ERR_MISSING_BY_TYPE;
        }
        if ($this->getMappingType() != self::TYPE_BY_TYPE && $this->getFieldName() == 'type') {
            return self::ERR_MISSING_VALUE;
        }
        return 0;
    }
    
    public function conditionToString()
    {
        global $lng;
        
        switch ($this->getMappingType()) {
            case self::TYPE_FIXED:

                if ($this->getFieldName() == 'part_id') {
                    return $lng->txt('ecs_field_' . $this->getFieldName()) . ': ' . $this->participantsToString();
                }
                return $lng->txt('ecs_field_' . $this->getFieldName()) . ': ' . $this->getMappingValue();
                
            case self::TYPE_DURATION:
                return $lng->txt('ecs_field_' . $this->getFieldName()) . ': ' . ilDatePresentation::formatPeriod(
                    $this->getDateRangeStart(),
                    $this->getDateRangeEnd()
                );
                
            case self::TYPE_BY_TYPE:
                return $lng->txt('type') . ': ' . $lng->txt('obj_' . $this->getByType());
        }
    }
    
    public function participantsToString()
    {
        include_once './Services/WebServices/ECS/classes/class.ilECSUtils.php';
        
        $part_string = "";
        $part = explode(',', $this->getMappingValue());
        $counter = 0;
        foreach ($part as $part_id) {
            if ($counter++) {
                $part_string .= ', ';
            }
            $part_string .= '"';
            
            $part_id_arr = explode('_', $part_id);
            if ($name = ilECSUtils::lookupParticipantName($part_id_arr[1], $part_id_arr[0])) {
                $part_string .= $name;
            } else {
                $part_string .= $part_id;
            }
            $part_string .= '"';
        }
        return $part_string;
    }

    public function matches(array $a_matchable_content)
    {
        if (isset($a_matchable_content[$this->getFieldName()])) {
            $value = $a_matchable_content[$this->getFieldName()];
            return $this->matchesValue($value[0], $value[1]);
        }
        return false;
    }
    
    protected function matchesValue($a_value, $a_type)
    {
        global $ilLog;
        
        
        switch ($a_type) {
            case self::ATTR_ARRAY:
                $values = explode(',', $a_value);
                $ilLog->write(__METHOD__ . ': Checking for value: ' . $a_value);
                $ilLog->write(__METHOD__ . ': Checking against attribute values: ' . $this->getMappingValue());
                break;
                
            case self::ATTR_INT:
                $ilLog->write(__METHOD__ . ': Checking for value: ' . $a_value);
                $ilLog->write(__METHOD__ . ': Checking against attribute values: ' . $this->getMappingValue());
                $values = array($a_value);
                break;
                
            case self::ATTR_STRING:
                $values = array($a_value);
                break;
        }
        $values = explode(',', $a_value);
        
        foreach ($values as $value) {
            $value = trim($value);
            switch ($this->getMappingType()) {
                case self::TYPE_FIXED:
                    
                    foreach ($this->getMappingAsArray() as $attribute_value) {
                        $attribute_value = trim($attribute_value);
                        if (strcasecmp($attribute_value, $value) == 0) {
                            return true;
                        }
                    }
                    break;
                    
                case self::TYPE_DURATION:
                    include_once './Services/Calendar/classes/class.ilDateTime.php';
                    $tmp_date = new ilDate($a_value, IL_CAL_UNIX);
                    return ilDateTime::_after($tmp_date, $this->getDateRangeStart()) and
                        ilDateTime::_before($tmp_date, $this->getDateRangeEnd());
            }
        }
        return false;
    }
    
    protected function read()
    {
        if (!$this->getMappingId()) {
            return false;
        }
        $res = $this->db->queryF(
            'SELECT * FROM ecs_container_mapping WHERE mapping_id = %s',
            array('integer'),
            array($this->getMappingId())
        );
        while ($row = $this->db->fetchObject($res)) {
            $this->setMappingId($row->mapping_id);
            $this->setDateRangeStart($row->date_range_start ? new ilDate($row->date_range_start, IL_CAL_UNIX) : null);
            $this->setDateRangeEnd($row->date_range_end ? new ilDate($row->date_range_end, IL_CAL_UNIX) : null);
            $this->setMappingType($row->mapping_type);
            $this->setFieldName($row->field_name);
            $this->setContainerId($row->container_id);
            
            if ($this->getMappingType() == self::TYPE_BY_TYPE) {
                $this->setByType($row->mapping_value);
            } else {
                $this->setMappingValue($row->mapping_value);
            }
        }
        return true;
    }
}