path: root/lib/classes/Config.class.php

<?php
/**
 * Config.class.php
 * provides access to global configuration
 *
 * 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.
 *
 * @author      André Noack <noack@data-quest.de>
 * @copyright   2010 Stud.IP Core-Group
 * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
 * @category    Stud.IP
*/

class Config implements ArrayAccess, Countable, IteratorAggregate
{
    private static $instance = null;

    /**
     * contains all config entries as field => value pairs
     * @var array
     */
    protected $data = [];
    /**
     * contains additional metadata for config fields
     * @var array
     */
    protected $metadata = [];

    /**
     * returns singleton instance
     * @return Config
     */
    public static function get()
    {
        if (self::$instance === null) {
            $config = new Config();
            self::$instance = $config;
        }
        return self::$instance;
    }

    /**
     * alias of Config::get() for compatibility
     * @return Config
     */
    public static function getInstance()
    {
        return self::get();
    }

    /**
     * use to set singleton instance for testing
     * or to unset by passing null
     * @param Config $my_instance
     */
    public static function set()
    {
        $my_instance = func_get_arg(0);
        self::$instance = $my_instance;
    }

    /**
     * pass array of config entries in field => value pairs
     * to circumvent fetching from database
     * @param array $data
     */
    public function __construct($data = null)
    {
        $this->fetchData($data);
    }

    /**
     * returns a list of config entry names, filtered by
     * given params
     * @param string filter by range: global, range, user, course or institute
     * @param string filter by section
     * @param string filter by part of name
     * @return array
     */
    public function getFields($range = null, $section = null, $name = null)
    {
        if ($range && !in_array($range, words('global range user course institute'))) {
            throw new Exception('Invalid range type');
        }

        $temp = $this->metadata;

        if ($range) {
            $temp = array_filter($temp, function ($a) use ($range) {
                return $a['range'] === $range
                    || ($a['range'] === 'range' && in_array($range, words('user course institute')));
            });
        }
        if ($section) {
            $temp = array_filter($temp, function ($a) use ($section) {
                return $a['section'] === $section;
            });
        }
        if ($name) {
            $temp = array_filter($temp, function ($a) use ($name) {
                return mb_stripos($a['field'], $name) !== false;
            });
        }

        return array_keys($temp);
    }

    /**
     * returns metadata for config entry
     * @param string $field
     * @return array
     */
    public function getMetadata($field)
    {
        return $this->metadata[$field] ?? [];
    }

    /**
     * returns value of config entry
     * for compatibility reasons an existing variable in global
     * namespace with the same name is also returned
     * @param string $field
     * @return mixed
     */
    public function getValue($field)
    {
        if (array_key_exists($field, $this->data)) {
            return $this->data[$field];
        }
        if (isset($GLOBALS[$field]) && !isset($_REQUEST[$field])) {
            return $GLOBALS[$field];
        }

        return null;
    }

    /**
     * set config entry to given value, but don't store it
     * in database
     * @param string $field
     * @param mixed $value
     * @return
     */
    public function setValue($field, $value)
    {
        if (array_key_exists($field, $this->data)) {
            return $this->data[$field] = $value;
        }
    }

    /**
     * IteratorAggregate
     *
     * @todo Add Traversable return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function getIterator()
    {
        return new ArrayIterator($this->data);
    }

    /**
     * magic method for dynamic properties
     */
    public function __get($field)
    {
        return $this->getValue($field);
    }

    /**
     * magic method for dynamic properties
     */
    public function __set($field, $value)
    {
         return $this->setValue($field, $value);
    }

    /**
     * magic method for dynamic properties
     */
    public function __isset($field)
    {
        return isset($this->data[$field]);
    }

    /**
     * ArrayAccess: Check whether the given offset exists.
     *
     * @todo Add bool return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function offsetExists($offset)
    {
        return isset($this->$offset);
    }

    /**
     * ArrayAccess: Get the value at the given offset.
     *
     * @todo Add mixed return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        return $this->$offset;
    }

    /**
     * ArrayAccess: Set the value at the given offset.
     *
     * @todo Add void return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function offsetSet($offset, $value)
    {
        $this->$offset = $value;
    }

    /**
     * ArrayAccess: unset the value at the given offset (not applicable)
     *
     * @todo Add void return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function offsetUnset($offset)
    {

    }

    /**
     * Countable
     *
     * @todo Add void return type when Stud.IP requires PHP8 minimal
     */
    #[ReturnTypeWillChange]
    public function count()
    {
        return count($this->data);
    }

    /**
     * fetch config data from table config
     * pass array to override database access
     * @param array $data
     */
    protected function fetchData($data = null)
    {
        if ($data !== null) {
            $this->data = $data;
        } else {
            $this->data = [];
            $db = DBManager::get();

            try {
                $query = "SELECT config.field, IFNULL(config_values.value, config.value) AS value, type, section, `range`, description,
                                 config_values.comment, config_values.value = config.value AS is_default
                          FROM config
                          LEFT JOIN config_values ON config.field = config_values.field AND range_id = 'studip'
                          ORDER BY section, config.field";
                $rs = $db->query($query);
            } catch (Exception $e) {
                //if migration is smaller than 226 and Stud.IP needs to be migrated to version 4.1 or greater:
                $query = "SELECT field, value, type, section, `range`, description, comment, is_default
                          FROM `config`
                          ORDER BY is_default DESC, section, field";
                $rs = $db->query($query);
            }

            while ($row = $rs->fetch(PDO::FETCH_ASSOC)) {
                // set the the type of the default entry for the modified entry
                if (!empty($this->metadata[$row['field']])) {
                    $row['type'] = $this->metadata[$row['field']]['type'];
                }

                $this->data[$row['field']] = $this->convertFromDatabase(
                    $row['type'],
                    $row['value'],
                    $row['field']
                );

                $this->metadata[$row['field']] = array_intersect_key($row, array_flip(words('type section range description is_default comment')));
                $this->metadata[$row['field']]['field'] = $row['field'];
                $this->metadata[$row['field']]['type']  = $row['type'] ?: 'string';
            }
        }
    }

    /**
     * store new value for existing config entry in database
     * posts notification ConfigValueChanged if entry is changed
     * @param string $field
     * @param string $data
     * @throws InvalidArgumentException
     * @return boolean
     */
    public function store($field, $data)
    {
        if (!is_array($data) || !isset($data['value'])) {
            $values['value'] = $data;
        } else {
            $values = $data;
        }

        $values['value'] = $this->convertForDatabase(
            $this->metadata[$field]['type'],
            $values['value'],
            $field
        );

        $entry = ConfigEntry::find($field);
        if (!isset($entry)) {
            throw new InvalidArgumentException($field . " not found in config table");
        }
        $ret = 0;
        if (isset($values['value'])) {
            $value_entry = new ConfigValue([$field, 'studip']);
            $old_value = $value_entry->isNew() ? $entry->value : $value_entry->value;
            $value_entry->value = $values['value'];
            if (isset($values['comment'])) {
                $value_entry->comment = $values['comment'];
            }
            if ($entry->isDefault($value_entry)) {
                $ret += $value_entry->delete();
            } else {
                $ret += $value_entry->store();
            }
        }

        if (isset($values['section'])) {
            $entry->section = $values['section'];
            $ret += $entry->store();
        }

        if ($ret) {
            $this->fetchData();
            if (isset($value_entry)) {
               NotificationCenter::postNotification('ConfigValueDidChange', $this, [
                   'field'     => $field,
                   'old_value' => $old_value,
                   'new_value' => $value_entry->value,
               ]);
            }
        }
        return $ret > 0;
    }

    /**
     * creates a new config entry in database
     * @param string name of entry
     * @param array data to insert as assoc array
     * @throws InvalidArgumentException
     * @return null|ConfigEntry
     */
    public function create($field, $data = [])
    {
        if (!$field) {
            throw new InvalidArgumentException("config fieldname is mandatory");
        }
        $entry = new ConfigEntry($field);
        if (!$entry->isNew()) {
            throw new InvalidArgumentException("config $field already exists");
        }
        $entry->setData($data);
        $ret = $entry->store() ? $entry : null;
        if ($ret) {
            $this->fetchData();
        }
        return $ret;
    }

    /**
     * delete config entry from database
     * @param string name of entry
     * @throws InvalidArgumentException
     * @return integer number of deleted rows
     */
    public function delete($field)
    {
        if (!$field) {
            throw new InvalidArgumentException("config fieldname is mandatory");
        }
        ConfigValue::deleteBySql('field=?', [$field]);
        $deleted = ConfigEntry::deleteBySql('field=?', [$field]);
        if ($deleted) {
            $this->fetchData();
        }
        return $deleted;
    }

    /**
     * Returns the identifier for the i18n field.
     * @param  string $field
     * @return string
     */
    protected function getI18NIdentifier($field)
    {
        return md5($field);
    }

    /**
     * Transforms the data from the database for use.
     *
     * @param  string $type
     * @param  mixed  $value
     * @param  string $field
     * @return mixed
     */
    public function convertFromDatabase($type, $value, $field)
    {
        if ($type === 'integer') {
            return (int) $value;
        }

        if ($type === 'boolean') {
            return (bool) $value;
        }

        if ($type === 'array') {
            return (array) json_decode($value, true);
        }

        if ($type === 'i18n') {
            return new I18NString($value, null, [
                'object_id' => $this->getI18NIdentifier($field),
                'table'     => 'config',
                'field'     => 'value',
            ]);
        }

        return (string) $value;
    }

    /**
     * Transforms the given value to be stored in the database.
     *
     * @param  string $type
     * @param  mixed  $value
     * @param  string $field
     * @return mixed
     */
    public function convertForDatabase($type, $value, $field)
    {
        if ($type === 'boolean') {
            return (bool) $value;
        }

        if ($type === 'integer') {
            return (int) $value;
        }

        if ($type === 'array') {
            return json_encode($value);
        }

        if ($type === 'i18n') {
            $value->setMetadata([
                'object_id' => $this->getI18NIdentifier($field),
                'table'     => 'config',
                'field'     => 'value',
            ]);
            $value->storeTranslations();

            return $value->original();
        }

        return (string) $value;
    }
}