icingaweb2-module-director/library/Director/Objects/IcingaObjectImports.php

<?php

namespace Icinga\Module\Director\Objects;

use Icinga\Exception\ProgrammingError;
use Iterator;
use Countable;
use Icinga\Module\Director\IcingaConfig\IcingaConfigRenderer;
use Icinga\Module\Director\IcingaConfig\IcingaConfigHelper as c;

class IcingaObjectImports implements Iterator, Countable, IcingaConfigRenderer
{
    protected $storedImports = array();

    protected $imports = array();

    protected $modified = false;

    protected $object;

    private $position = 0;

    protected $idx = array();

    public function __construct(IcingaObject $object)
    {
        $this->object = $object;
    }

    public function count()
    {
        return count($this->imports);
    }

    public function rewind()
    {
        $this->position = 0;
    }

    public function hasBeenModified()
    {
        return $this->modified;
    }

    public function current()
    {
        if (! $this->valid()) {
            return null;
        }

        return $this->imports[$this->idx[$this->position]];
    }

    public function key()
    {
        return $this->idx[$this->position];
    }

    public function next()
    {
        ++$this->position;
    }

    public function valid()
    {
        return array_key_exists($this->position, $this->idx);
    }

    public function get($key)
    {
        if (array_key_exists($key, $this->imports)) {
            return $this->imports[$key];
        }

        return null;
    }

    public function set($import)
    {
        $existing = array_keys($this->imports);
        $new = array();
        $class = $this->getImportClass();
        foreach ($import as $i) {

            if ($i instanceof $class) {
                $new[] = $i->object_name;
            } else {
                $new[] = $i;
            }
        }
        sort($existing);
        sort($new);
        if ($existing === $new) {
            return $this;
        }

        $this->imports = array();
        return $this->add($import);
    }

    /**
     * Magic isset check
     *
     * @return boolean
     */
    public function __isset($import)
    {
        return array_key_exists($import, $this->imports);
    }

    public function remove($import)
    {
        if (array_key_exists($import, $this->imports)) {
            unset($this->imports[$import]);
        }

        $this->modified = true;
        $this->refreshIndex();
    }

    protected function refreshIndex()
    {
        ksort($this->imports);
        $this->idx = array_keys($this->imports);
    }

    public function add($import)
    {
        // TODO: only one query when adding array
        if (is_array($import)) {
            foreach ($import as $i) {
                $this->add($i);
            }
            return $this;
        }

        if (array_key_exists($import, $this->imports)) {
            return $this;
        }

        $class = $this->getImportClass();
        $connection = $this->object->getConnection();

        if ($import instanceof $class) {
            $this->imports[$import->object_name] = $import;
        } elseif (is_string($import)) {
            $query = $this->object->getDb()->select()->from(
                $this->object->getTableName()
            )->where('object_name = ?', $import);
            $imports = $class::loadAll($connection, $query, 'object_name');
        }
        if (! array_key_exists($import, $imports)) {
            throw new ProgrammingError(
                'The import "%s" doesn\'t exists.',
                $import
            );
        }

        var_dump($imports);die;
        $this->imports[$import] = $imports[$import];

        $this->modified = true;
        $this->refreshIndex();

        return $this;
    }

    protected function getImportTableName()
    {
        return $this->object->getTableName() . '_inheritance';
    }

    public function listImportNames()
    {
        return array_keys($this->imports);
    }

    public function getType()
    {
        return $this->object->getShortTableName();
    }

    protected function loadFromDb()
    {
        $db = $this->object->getDb();
        $connection = $this->object->getConnection();

        $type = $this->getType();

        $table = $this->object->getTableName();
        $query = $db->select()->from(
            array('o' => $table),
            array()
        )->join(
            array('oi' => $table . '_inheritance'),
            'oi.' . $type . '_id = o.id',
            array()
        )->join(
            array('i' => $table),
            'i.id = oi.parent_' . $type . '_id',
            '*'
        )->where('o.id = ?', (int) $this->object->id)
        ->order('oi.weight');

        $class = $this->getImportClass();
        $this->imports = $class::loadAll($connection, $query, 'object_name');
        $this->storedImports = $this->imports;

        return $this;
    }

    /**
     * Modification TODO
     *
     * @return $this
     */
    public function store()
    {
        $storedGroups = array_keys($this->storedGroups);
        $groups = array_keys($this->groups);

        $objectId = $this->object->id;
        $type = $this->getType();

        $objectCol = $type . '_id';
        $groupCol = $type . 'group_id';

        $toDelete = array_diff($storedGroups, $groups);
        foreach ($toDelete as $group) {
            $where = sprintf(
                $objectCol . ' = %d AND ' . $groupCol . ' = %d',
                $objectId,
                $this->storedGroups[$group]->id
            );

            $this->object->db->delete(
                $this->getGroupMemberTableName(),
                $where
            );
        }

        $toAdd = array_diff($groups, $storedGroups);
        foreach ($toAdd as $group) {
            $this->object->db->insert(
                $this->getGroupMemberTableName(),
                array(
                    $objectCol => $objectId,
                    $groupCol => $this->groups[$group]->id
                )
            );
        }
        $this->storedGroups = $this->groups;

        return $this;
    }

    protected function getImportClass()
    {
        return get_class($this->object);
    }

    public static function loadForStoredObject(IcingaObject $object)
    {
        $imports = new static($object);
        return $imports->loadFromDb();
    }

    public function toConfigString()
    {
        $ret = '';

        foreach ($this->imports as $name => & $o) {
            $ret .= '    import ' . c::renderString($o->object_name) . "\n";
        }

        if ($ret !== '') {
            $ret .= "\n";
        }
        return $ret;
    }

    public function __toString()
    {
        try {
            return $this->toConfigString();
        } catch (Exception $e) {
            trigger_error($e);
            $previousHandler = set_exception_handler(function () {});
            restore_error_handler();
            if ($previousHandler !== null) {
                call_user_func($previousHandler, $e);
                die();
            } else {
                die($e->getMessage());
            }
        }
    }
}