Node.php

Go to the documentation of this file.

<?php
 
namespace PlanetTeamSpeak\TeamSpeak3Framework\Node;
 
use ArrayAccess;
use Countable;
use PlanetTeamSpeak\TeamSpeak3Framework\Adapter\ServerQuery;
use PlanetTeamSpeak\TeamSpeak3Framework\Adapter\ServerQuery\Reply;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\AdapterException;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\NodeException;
use PlanetTeamSpeak\TeamSpeak3Framework\Exception\ServerQueryException;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\Convert;
use PlanetTeamSpeak\TeamSpeak3Framework\Helper\StringHelper;
use PlanetTeamSpeak\TeamSpeak3Framework\Viewer\ViewerInterface;
use RecursiveIterator;
use RecursiveIteratorIterator;

abstract class Node implements RecursiveIterator, ArrayAccess, Countable
{
    protected Node|null|ServerQuery $parent = null;

    protected array|null $server = null;

    protected int $nodeId = 0x00;

    protected array|null $nodeList = null;

    protected array $nodeInfo = [];

    protected array $storage = [];

    public function request(string $cmd, bool $throw = true): Reply
    {
        return $this->getParent()->request($cmd, $throw);
    }

    public function prepare(string $cmd, array $params = []): StringHelper
    {
        return StringHelper::factory($this->getParent()->prepare($cmd, $params));
    }

    public function execute($cmd, array $params = []): Reply
    {
        return $this->request($this->prepare($cmd, $params));
    }

    public function getParent(): ServerQuery|Node|null
    {
        return $this->parent;
    }

    public function getId(): int
    {
        return $this->nodeId;
    }

    public function iconIsLocal(string $key): bool
    {
        $iconid = $this[$key];
        if (!is_int($iconid)) {
            $iconid = $iconid->toInt();
        }
 
        return $iconid > 0 && $iconid < 1000;
    }

    public function iconGetName(string $key): StringHelper
    {
        $iconid = $this[$key];
        if (!is_int($iconid)) {
            $iconid = $iconid->toInt();
        }
 
        $iconid = ($iconid < 0) ? (pow(2, 32)) - ($iconid * -1) : $iconid;
 
        return new StringHelper("/icon_" . $iconid);
    }

    public function getClass(string $prefix = "ts3_"): string
    {
        if ($this instanceof Channel && $this->isSpacer()) {
            return $prefix . "spacer";
        } elseif ($this instanceof Client && $this["client_type"]) {
            return $prefix . "query";
        }
 
        return $prefix . StringHelper::factory(get_class($this))->section("_", 2)->toLower();
    }

    abstract public function getUniqueId(): string;

    abstract public function getIcon(): string;

    abstract public function getSymbol(): string;

    public function getViewer(ViewerInterface $viewer): string
    {
        $html = $viewer->fetchObject($this);
 
        $iterator = new RecursiveIteratorIterator($this, RecursiveIteratorIterator::SELF_FIRST);
 
        foreach ($iterator as $node) {
            $siblings = [];
 
            for ($level = 0; $level < $iterator->getDepth(); $level++) {
                $siblings[] = ($iterator->getSubIterator($level)->hasNext()) ? 1 : 0;
            }
 
            $siblings[] = (!$iterator->getSubIterator($level)->hasNext()) ? 1 : 0;
 
            $html .= $viewer->fetchObject($node, $siblings);
        }
 
        if (empty($html) && method_exists($viewer, "toString")) {
            return $viewer->toString();
        }
 
        return $html;
    }

    protected function filterList(array $nodes = [], array $rules = []): array
    {
        if (!empty($rules)) {
            foreach ($nodes as $node) {
                if (!$node instanceof Node) {
                    continue;
                }
 
                $props = $node->getInfo(false);
                $props = array_intersect_key($props, $rules);
 
                foreach ($props as $key => $val) {
                    if ($val instanceof StringHelper) {
                        $match = $val->contains($rules[$key], true);
                    } else {
                        $match = $val == $rules[$key];
                    }
 
                    if ($match === false) {
                        unset($nodes[$node->getId()]);
                    }
                }
            }
        }
 
        return $nodes;
    }

    public function getInfo(bool $extend = true, bool $convert = false): array
    {
        if ($extend) {
            $this->fetchNodeInfo();
        }
 
        if ($convert) {
            $info = $this->nodeInfo;
 
            foreach ($info as $key => $val) {
                $key = StringHelper::factory($key);
 
                if ($key->contains("_bytes_")) {
                    $info[$key->toString()] = Convert::bytes($val);
                } elseif ($key->contains("_bandwidth_")) {
                    $info[$key->toString()] = Convert::bytes($val) . "/s";
                } elseif ($key->contains("_packets_")) {
                    $info[$key->toString()] = number_format($val, 0, null, ".");
                } elseif ($key->contains("_packetloss_")) {
                    $info[$key->toString()] = sprintf("%01.2f", floatval($val instanceof StringHelper ? $val->toString() : strval($val)) * 100) . "%";
                } elseif ($key->endsWith("_uptime")) {
                    $info[$key->toString()] = Convert::seconds($val);
                } elseif ($key->endsWith("_version")) {
                    $info[$key->toString()] = Convert::version($val);
                } elseif ($key->endsWith("_icon_id")) {
                    $info[$key->toString()] = $this->iconGetName($key)->filterDigits();
                }
            }
 
            return $info;
        }
 
        return $this->nodeInfo;
    }

    public function getProperty(string $property, mixed $default = null): mixed
    {
        if (!$this->offsetExists($property)) {
            $this->fetchNodeInfo();
        }
 
        if (!$this->offsetExists($property)) {
            return $default;
        }
 
        return $this->nodeInfo[$property];
    }

    public function __toString()
    {
        return get_class($this);
    }

    public function toString(): string
    {
        return $this->__toString();
    }

    public function toArray(): array
    {
        return $this->nodeList;
    }

    public function __call(string $name, array $args)
    {
        if ($this->getParent() instanceof Node) {
            return call_user_func_array([$this->getParent(), $name], $args);
        }
 
        throw new NodeException("node method '" . $name . "()' does not exist");
    }

    protected function setStorage(string $key, mixed $val): void
    {
        $this->storage[$key] = $val;
    }

    protected function getStorage(string $key, mixed $default = null): mixed
    {
        return !empty($this->storage[$key]) ? $this->storage[$key] : $default;
    }

    protected function delStorage(string $key): void
    {
        unset($this->storage[$key]);
    }

    public function __sleep()
    {
        return ["parent", "storage", "nodeId"];
    }

    protected function fetchNodeList()
    {
        $this->nodeList = [];
    }

    protected function fetchNodeInfo()
    {
    }

    protected function resetNodeInfo()
    {
        $this->nodeInfo = [];
    }

    protected function verifyNodeList()
    {
        if ($this->nodeList === null) {
            $this->fetchNodeList();
        }
    }

    protected function resetNodeList()
    {
        $this->nodeList = null;
    }

    public function count(): int
    {
        $this->verifyNodeList();
 
        return count($this->nodeList);
    }

    public function current(): mixed
    {
        $this->verifyNodeList();
 
        return current($this->nodeList);
    }

    public function getChildren(): null|RecursiveIterator
    {
        $this->verifyNodeList();
 
        return $this->current();
    }

    public function hasChildren(): bool
    {
        $this->verifyNodeList();
 
        return $this->current()->count() > 0;
    }

    public function hasNext(): bool
    {
        $this->verifyNodeList();
 
        return $this->key() + 1 < $this->count();
    }

    public function key(): string|int|null
    {
        $this->verifyNodeList();
 
        return key($this->nodeList);
    }

    public function valid(): bool
    {
        $this->verifyNodeList();
 
        return $this->key() !== null;
    }

    public function next(): void
    {
        $this->verifyNodeList();
 
        next($this->nodeList);
    }

    public function rewind(): void
    {
        $this->verifyNodeList();
 
        reset($this->nodeList);
    }

    public function offsetExists($offset): bool
    {
        return array_key_exists((string)$offset, $this->nodeInfo);
    }

    public function offsetGet($offset): mixed
    {
        if (!$this->offsetExists($offset)) {
            $this->fetchNodeInfo();
        }
 
        if (!$this->offsetExists($offset)) {
            throw new NodeException("node '" . get_class($this) . "' has no property named '" . $offset . "'");
        }
 
        return $this->nodeInfo[(string)$offset];
    }

    public function offsetSet($offset, $value): void
    {
        if (method_exists($this, "modify")) {
            $this->modify([(string)$offset => $value]);
            return;
        }
 
        throw new NodeException("node '" . get_class($this) . "' is read only");
    }

    public function offsetUnset($offset): void
    {
        unset($this->nodeInfo[(string)$offset]);
    }

    public function __get($offset)
    {
        return $this->offsetGet($offset);
    }

    public function __set($offset, $value)
    {
        $this->offsetSet($offset, $value);
    }
}