<?php

/**
 * @file
 * TeamSpeak 3 PHP Framework
 *
 * $Id: Server.php 10/11/2013 11:35:21 scp@orilla $
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 * @package   TeamSpeak3
 * @version   1.1.23
 * @author    Sven 'ScP' Paulsen
 * @copyright Copyright (c) 2010 by Planet TeamSpeak. All rights reserved.
 */

namespace TeamSpeak3\Node;

use TeamSpeak3\Adapter\ServerQuery\Reply;
use TeamSpeak3\Helper\Signal;
use TeamSpeak3\Helper\StringHelper;
use TeamSpeak3\TeamSpeak3;
use TeamSpeak3\Ts3Exception;

/**
 * @class Server
 * @brief Class describing a TeamSpeak 3 virtual server and all it's parameters.
 */
class Server extends AbstractNode
{
    /**
     * @ignore
     */
    protected $channelList = null;

    /**
     * @ignore
     */
    protected $clientList = null;

    /**
     * @ignore
     */
    protected $sgroupList = null;

    /**
     * @ignore
     */
    protected $cgroupList = null;

    /**
     * The Server constructor.
     *
     * @param  Host $host
     * @param  array $info
     * @param  string $index
     * @throws Ts3Exception
     * @return Server
     */
    public function __construct(Host $host, array $info, $index = "virtualserver_id")
    {
        $this->parent = $host;
        $this->nodeInfo = $info;

        if (!array_key_exists($index, $this->nodeInfo)) {
            throw new Ts3Exception("invalid serverID", 0x400);
        }

        $this->nodeId = $this->nodeInfo[$index];
    }

    /**
     * Sends a prepared command to the server and returns the result.
     *
     * @param  string $cmd
     * @param  boolean $throw
     * @return Reply
     */
    public function request($cmd, $throw = true)
    {
        if ($this->getId() != $this->getParent()->serverSelectedId()) {
            $this->getParent()->serverSelect($this->getId());
        }

        return $this->getParent()->request($cmd, $throw);
    }

    /**
     * Returns an array filled with Channel objects.
     *
     * @param  array $filter
     * @return array
     */
    public function channelList(array $filter = array())
    {
        if ($this->channelList === null) {
            $channels = $this->request("channellist -topic -flags -voice -limits -icon")->toAssocArray("cid");

            $this->channelList = array();

            foreach ($channels as $cid => $channel) {
                $this->channelList[$cid] = new Channel($this, $channel);
            }

            $this->resetNodeList();
        }

        return $this->filterList($this->channelList, $filter);
    }

    /**
     * Resets the list of channels online.
     *
     * @return void
     */
    public function channelListReset()
    {
        $this->resetNodeList();
        $this->channelList = null;
    }

    /**
     * Creates a new channel using given properties and returns the new ID.
     *
     * @param  array $properties
     * @return integer
     */
    public function channelCreate(array $properties)
    {
        $cid = $this->execute("channelcreate", $properties)->toList();
        $this->channelListReset();

        if (!isset($properties["client_flag_permanent"]) && !isset($properties["client_flag_semi_permanent"])) {
            $this->getParent()->whoamiSet("client_channel_id", $cid["cid"]);
        }

        return $cid["cid"];
    }

    /**
     * Deletes the channel specified by $cid.
     *
     * @param  integer $cid
     * @param  boolean $force
     * @return void
     */
    public function channelDelete($cid, $force = false)
    {
        $this->execute("channeldelete", array("cid" => $cid, "force" => $force));
        $this->channelListReset();

        if (($cid instanceof AbstractNode ? $cid->getId() : $cid) == $this->whoamiGet(
                "client_channel_id"
            )
        ) {
            $this->getParent()->whoamiReset();
        }
    }

    /**
     * Moves the channel specified by $cid to the parent channel specified with $pid.
     *
     * @param  integer $cid
     * @param  integer $pid
     * @param  integer $order
     * @return void
     */
    public function channelMove($cid, $pid, $order = null)
    {
        $this->execute("channelmove", array("cid" => $cid, "cpid" => $pid, "order" => $order));
        $this->channelListReset();
    }

    /**
     * Returns TRUE if the given Channel object is a spacer.
     *
     * @param  Channel $channel
     * @return boolean
     */
    public function channelIsSpacer(Channel $channel)
    {
        return (preg_match(
                "/\[[^\]]*spacer[^\]]*\]/",
                $channel
            ) && $channel["channel_flag_permanent"] && !$channel["pid"]) ? true : false;
    }

    /**
     * Creates a new channel spacer and returns the new ID. The first parameter $ident is used to create a
     * unique spacer name on the virtual server.
     *
     * @param  string $ident
     * @param  mixed $type
     * @param  integer $align
     * @param  integer $order
     * @param  integer $maxclients
     * @throws Ts3Exception
     * @return integer
     */
    public function channelSpacerCreate(
        $ident,
        $type = TeamSpeak3::SPACER_SOLIDLINE,
        $align = TeamSpeak3::SPACER_ALIGN_REPEAT,
        $order = null,
        $maxclients = 0
    ) {
        $properties = array(
            "channel_name_phonetic" => "channel spacer",
            "channel_codec" => TeamSpeak3::CODEC_OPUS_VOICE,
            "channel_codec_quality" => 0x00,
            "channel_flag_permanent" => true,
            "channel_flag_maxclients_unlimited" => false,
            "channel_flag_maxfamilyclients_unlimited" => false,
            "channel_flag_maxfamilyclients_inherited" => false,
            "channel_maxclients" => $maxclients,
            "channel_order" => $order,
        );

        switch ($align) {
            case TeamSpeak3::SPACER_ALIGN_REPEAT:
                $properties["channel_name"] = "[*spacer" . strval($ident) . "]";
                break;

            case TeamSpeak3::SPACER_ALIGN_LEFT:
                $properties["channel_name"] = "[lspacer" . strval($ident) . "]";
                break;

            case TeamSpeak3::SPACER_ALIGN_RIGHT:
                $properties["channel_name"] = "[rspacer" . strval($ident) . "]";
                break;

            case TeamSpeak3::SPACER_ALIGN_CENTER:
                $properties["channel_name"] = "[cspacer" . strval($ident) . "]";
                break;

            default:
                throw new Ts3Exception("missing required parameter", 0x606);
                break;
        }

        switch ($type) {
            case (string)TeamSpeak3::SPACER_SOLIDLINE:
                $properties["channel_name"] .= "___";
                break;

            case (string)TeamSpeak3::SPACER_DASHLINE:
                $properties["channel_name"] .= "---";
                break;

            case (string)TeamSpeak3::SPACER_DOTLINE:
                $properties["channel_name"] .= "...";
                break;

            case (string)TeamSpeak3::SPACER_DASHDOTLINE:
                $properties["channel_name"] .= "-.-";
                break;

            case (string)TeamSpeak3::SPACER_DASHDOTDOTLINE:
                $properties["channel_name"] .= "-..";
                break;

            default:
                $properties["channel_name"] .= strval($type);
                break;
        }

        return $this->channelCreate($properties);
    }

    /**
     * Returns the possible type of a channel spacer.
     *
     * @param  integer $cid
     * @throws Ts3Exception
     * @return integer
     */
    public function channelSpacerGetType($cid)
    {
        $channel = $this->channelGetById($cid);

        if (!$this->channelIsSpacer($channel)) {
            throw new Ts3Exception("invalid channel flags", 0x307);
        }

        switch ($channel["channel_name"]->section("]", 1)) {
            case "___":
                return TeamSpeak3::SPACER_SOLIDLINE;

            case "---":
                return TeamSpeak3::SPACER_DASHLINE;

            case "...":
                return TeamSpeak3::SPACER_DOTLINE;

            case "-.-":
                return TeamSpeak3::SPACER_DASHDOTLINE;

            case "-..":
                return TeamSpeak3::SPACER_DASHDOTDOTLINE;

            default:
                return TeamSpeak3::SPACER_CUSTOM;
        }
    }

    /**
     * Returns the possible alignment of a channel spacer.
     *
     * @param  integer $cid
     * @throws Ts3Exception
     * @return integer
     */
    public function channelSpacerGetAlign($cid)
    {
        $channel = $this->channelGetById($cid);

        if (!$this->channelIsSpacer($channel) || !preg_match(
                "/\[(.*)spacer.*\]/",
                $channel,
                $matches
            ) || !isset($matches[1])
        ) {
            throw new Ts3Exception("invalid channel flags", 0x307);
        }

        switch ($matches[1]) {
            case "*":
                return TeamSpeak3::SPACER_ALIGN_REPEAT;

            case "c":
                return TeamSpeak3::SPACER_ALIGN_CENTER;

            case "r":
                return TeamSpeak3::SPACER_ALIGN_RIGHT;

            default:
                return TeamSpeak3::SPACER_ALIGN_LEFT;
        }
    }

    /**
     * Returns a list of permissions defined for a specific channel.
     *
     * @param  integer $cid
     * @param  boolean $permsid
     * @return array
     */
    public function channelPermList($cid, $permsid = false)
    {
        return $this->execute("channelpermlist", array("cid" => $cid, $permsid ? "-permsid" : null))->toAssocArray(
            $permsid ? "permsid" : "permid"
        );
    }

    /**
     * Adds a set of specified permissions to a channel. Multiple permissions can be added by
     * providing the two parameters of each permission.
     *
     * @param  integer $cid
     * @param  integer $permid
     * @param  integer $permvalue
     * @return void
     */
    public function channelPermAssign($cid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("channeladdperm", array("cid" => $cid, $permident => $permid, "permvalue" => $permvalue));
    }

    /**
     * Removes a set of specified permissions from a channel. Multiple permissions can be removed at once.
     *
     * @param  integer $cid
     * @param  integer $permid
     * @return void
     */
    public function channelPermRemove($cid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("channeldelperm", array("cid" => $cid, $permident => $permid));
    }

    /**
     * Returns a list of permissions defined for a client in a specific channel.
     *
     * @param  integer $cid
     * @param  integer $cldbid
     * @param  boolean $permsid
     * @return array
     */
    public function channelClientPermList($cid, $cldbid, $permsid = false)
    {
        return $this->execute(
            "channelclientpermlist",
            array("cid" => $cid, "cldbid" => $cldbid, $permsid ? "-permsid" : null)
        )->toAssocArray($permsid ? "permsid" : "permid");
    }

    /**
     * Adds a set of specified permissions to a client in a specific channel. Multiple permissions can be added by
     * providing the two parameters of each permission.
     *
     * @param  integer $cid
     * @param  integer $cldbid
     * @param  integer $permid
     * @param  integer $permvalue
     * @return void
     */
    public function channelClientPermAssign($cid, $cldbid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute(
            "channelclientaddperm",
            array("cid" => $cid, "cldbid" => $cldbid, $permident => $permid, "permvalue" => $permvalue)
        );
    }

    /**
     * Removes a set of specified permissions from a client in a specific channel. Multiple permissions can be removed at once.
     *
     * @param  integer $cid
     * @param  integer $cldbid
     * @param  integer $permid
     * @return void
     */
    public function channelClientPermRemove($cid, $cldbid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("channelclientdelperm", array("cid" => $cid, "cldbid" => $cldbid, $permident => $permid));
    }

    /**
     * Returns a list of files and directories stored in the specified channels file repository.
     *
     * @param  integer $cid
     * @param  string $cpw
     * @param  string $path
     * @param  boolean $recursive
     * @return array
     */
    public function channelFileList($cid, $cpw = "", $path = "/", $recursive = false)
    {
        $files = $this->execute("ftgetfilelist", array("cid" => $cid, "cpw" => $cpw, "path" => $path))->toArray();
        $count = count($files);

        for ($i = 0; $i < $count; $i++) {
            $files[$i]["sid"] = $this->getId();
            $files[$i]["cid"] = $files[0]["cid"];
            $files[$i]["path"] = $files[0]["path"];
            $files[$i]["src"] = new StringHelper($cid ? $files[$i]["path"] : "/");

            if (!$files[$i]["src"]->endsWith("/")) {
                $files[$i]["src"]->append("/");
            }

            $files[$i]["src"]->append($files[$i]["name"]);

            if ($recursive && $files[$i]["type"] == TeamSpeak3::FILE_TYPE_DIRECTORY) {
                $files = array_merge(
                    $files,
                    $this->channelFileList($cid, $cpw, $path . $files[$i]["name"], $recursive)
                );
            }
        }

        uasort($files, array(__CLASS__, "sortFileList"));

        return $files;
    }

    /**
     * Returns detailed information about the specified file stored in a channels file repository.
     *
     * @param  integer $cid
     * @param  string $cpw
     * @param  string $name
     * @return array
     */
    public function channelFileInfo($cid, $cpw = "", $name = "/")
    {
        return array_pop(
            $this->execute("ftgetfileinfo", array("cid" => $cid, "cpw" => $cpw, "name" => $name))->toArray()
        );
    }

    /**
     * Renames a file in a channels file repository. If the two parameters $tcid and $tcpw are specified, the file
     * will be moved into another channels file repository.
     *
     * @param  integer $cid
     * @param  string $cpw
     * @param  string $oldname
     * @param  string $newname
     * @param  integer $tcid
     * @param  string $tcpw
     * @return void
     */
    public function channelFileRename($cid, $cpw = "", $oldname = "/", $newname = "/", $tcid = null, $tcpw = null)
    {
        $this->execute(
            "ftrenamefile",
            array(
                "cid" => $cid,
                "cpw" => $cpw,
                "oldname" => $oldname,
                "newname" => $newname,
                "tcid" => $tcid,
                "tcpw" => $tcpw
            )
        );
    }

    /**
     * Deletes one or more files stored in a channels file repository.
     *
     * @param  integer $cid
     * @param  string $cpw
     * @param  string $name
     * @return void
     */
    public function channelFileDelete($cid, $cpw = "", $name = "/")
    {
        $this->execute("ftdeletefile", array("cid" => $cid, "cpw" => $cpw, "name" => $name));
    }

    /**
     * Creates new directory in a channels file repository.
     *
     * @param  integer $cid
     * @param  string $cpw
     * @param  string $dirname
     * @return void
     */
    public function channelDirCreate($cid, $cpw = "", $dirname = "/")
    {
        $this->execute("ftcreatedir", array("cid" => $cid, "cpw" => $cpw, "dirname" => $dirname));
    }

    /**
     * Returns the level of a channel.
     *
     * @param  integer $cid
     * @return integer
     */
    public function channelGetLevel($cid)
    {
        $channel = $this->channelGetById($cid);
        $levelno = 0;

        if ($channel["pid"]) {
            $levelno = $this->channelGetLevel($channel["pid"]) + 1;
        }

        return $levelno;
    }

    /**
     * Returns the pathway of a channel which can be used as a clients default channel.
     *
     * @param  integer $cid
     * @return string
     */
    public function channelGetPathway($cid)
    {
        $channel = $this->channelGetById($cid);
        $pathway = $channel["channel_name"];

        if ($channel["pid"]) {
            $pathway = $this->channelGetPathway($channel["pid"]) . "/" . $channel["channel_name"];
        }

        return $pathway;
    }

    /**
     * Returns the Channel object matching the given ID.
     *
     * @param  integer $cid
     * @throws Ts3Exception
     * @return Channel
     */
    public function channelGetById($cid)
    {
        if (!array_key_exists((string)$cid, $this->channelList())) {
            throw new Ts3Exception("invalid channelID", 0x300);
        }

        return $this->channelList[intval((string)$cid)];
    }

    /**
     * Returns the Channel object matching the given name.
     *
     * @param  string $name
     * @throws Ts3Exception
     * @return Channel
     */
    public function channelGetByName($name)
    {
        foreach ($this->channelList() as $channel) {
            if ($channel["channel_name"] == $name) {
                return $channel;
            }
        }

        throw new Ts3Exception("invalid channelID", 0x300);
    }

    /**
     * Returns an array filled with Client objects.
     *
     * @param  array $filter
     * @return array
     */
    public function clientList(array $filter = array())
    {
        if ($this->clientList === null) {
            $clients = $this->request(
                "clientlist -uid -away -badges -voice -info -times -groups -icon -country -ip"
            )->toAssocArray("clid");

            $this->clientList = array();

            foreach ($clients as $clid => $client) {
                if ($this->getParent()->getExcludeQueryClients() && $client["client_type"]) {
                    continue;
                }

                $this->clientList[$clid] = new Client($this, $client);
            }

            uasort($this->clientList, array(__CLASS__, "sortClientList"));

            $this->resetNodeList();
        }

        return $this->filterList($this->clientList, $filter);
    }

    /**
     * Resets the list of clients online.
     *
     * @return void
     */
    public function clientListReset()
    {
        $this->resetNodeList();
        $this->clientList = null;
    }

    /**
     * Returns a list of clients matching a given name pattern.
     *
     * @param  string $pattern
     * @return array
     */
    public function clientFind($pattern)
    {
        return $this->execute("clientfind", array("pattern" => $pattern))->toAssocArray("clid");
    }

    /**
     * Returns a list of client identities known by the virtual server. By default, the server spits out 25 entries
     * at once.
     *
     * @param  integer $offset
     * @param  integer $limit
     * @return array
     */
    public function clientListDb($offset = null, $limit = null)
    {
        return $this->execute("clientdblist -count", array("start" => $offset, "duration" => $limit))->toAssocArray(
            "cldbid"
        );
    }

    /**
     * Returns the number of client identities known by the virtual server.
     *
     * @return integer
     */
    public function clientCountDb()
    {
        return current($this->execute("clientdblist -count", array("duration" => 1))->toList("count"));
    }

    /**
     * Returns a list of properties from the database for the client specified by $cldbid.
     *
     * @param  integer $cldbid
     * @return array
     */
    public function clientInfoDb($cldbid)
    {
        return $this->execute("clientdbinfo", array("cldbid" => $cldbid))->toList();
    }

    /**
     * Returns a list of client database IDs matching a given pattern. You can either search for a clients
     * last known nickname or his unique identity by using the $uid option.
     *
     * @param  string $pattern
     * @param  boolean $uid
     * @return array
     */
    public function clientFindDb($pattern, $uid = false)
    {
        return array_keys(
            $this->execute("clientdbfind", array("pattern" => $pattern, ($uid) ? "-uid" : null))->toAssocArray("cldbid")
        );
    }

    /**
     * Returns the number of regular clients online.
     *
     * @return integer
     */
    public function clientCount()
    {
        if ($this->isOffline()) {
            return 0;
        }

        return $this["virtualserver_clientsonline"] - $this["virtualserver_queryclientsonline"];
    }

    /**
     * Returns the Client object matching the given ID.
     *
     * @param  integer $clid
     * @throws Ts3Exception
     * @return Client
     */
    public function clientGetById($clid)
    {
        if (!array_key_exists((string)$clid, $this->clientList())) {
            throw new Ts3Exception("invalid clientID", 0x200);
        }

        return $this->clientList[intval((string)$clid)];
    }

    /**
     * Returns the Client object matching the given name.
     *
     * @param  string $name
     * @throws Ts3Exception
     * @return Client
     */
    public function clientGetByName($name)
    {
        foreach ($this->clientList() as $client) {
            if ($client["client_nickname"] == $name) {
                return $client;
            }
        }

        throw new Ts3Exception("invalid clientID", 0x200);
    }

    /**
     * Returns the Client object matching the given unique identifier.
     *
     * @param  string $uid
     * @throws Ts3Exception
     * @return Client
     */
    public function clientGetByUid($uid)
    {
        foreach ($this->clientList() as $client) {
            if ($client["client_unique_identifier"] == $uid) {
                return $client;
            }
        }

        throw new Ts3Exception("invalid clientID", 0x200);
    }

    /**
     * Returns the Client object matching the given database ID.
     *
     * @param  integer $dbid
     * @throws Ts3Exception
     * @return Client
     */
    public function clientGetByDbid($dbid)
    {
        foreach ($this->clientList() as $client) {
            if ($client["client_database_id"] == $dbid) {
                return $client;
            }
        }

        throw new Ts3Exception("invalid clientID", 0x200);
    }

    /**
     * Returns an array containing the last known nickname and the database ID of the client matching
     * the unique identifier specified with $cluid.
     *
     * @param  string $cluid
     * @return array
     */
    public function clientGetNameByUid($cluid)
    {
        return $this->execute("clientgetnamefromuid", array("cluid" => $cluid))->toList();
    }

    /**
     * Returns an array containing a list of active client connections using the unique identifier
     * specified with $cluid.
     *
     * @param  string $cluid
     * @return array
     */
    public function clientGetIdsByUid($cluid)
    {
        return $this->execute("clientgetids", array("cluid" => $cluid))->toAssocArray("clid");
    }

    /**
     * Returns an array containing the last known nickname and the unique identifier of the client
     * matching the database ID specified with $cldbid.
     *
     * @param  string $cldbid
     * @return array
     */
    public function clientGetNameByDbid($cldbid)
    {
        return $this->execute("clientgetnamefromdbid", array("cldbid" => $cldbid))->toList();
    }

    /**
     * Returns an array containing the names and IDs of all server groups the client specified with
     * $cldbid is is currently residing in.
     *
     * @param  string $cldbid
     * @return array
     */
    public function clientGetServerGroupsByDbid($cldbid)
    {
        return $this->execute("servergroupsbyclientid", array("cldbid" => $cldbid))->toAssocArray("sgid");
    }

    /**
     * Moves a client to another channel.
     *
     * @param  integer $clid
     * @param  integer $cid
     * @param  string $cpw
     * @return void
     */
    public function clientMove($clid, $cid, $cpw = null)
    {
        $this->clientListReset();

        $this->execute("clientmove", array("clid" => $clid, "cid" => $cid, "cpw" => $cpw));

        if ($clid instanceof AbstractNode) {
            $clid = $clid->getId();
        }

        if ($cid instanceof AbstractNode) {
            $cid = $cid->getId();
        }

        if (!is_array($clid) && $clid == $this->whoamiGet("client_id")) {
            $this->getParent()->whoamiSet("client_channel_id", $cid);
        }
    }

    /**
     * Kicks one or more clients from their currently joined channel or from the server.
     *
     * @param  integer $clid
     * @param  integer $reasonid
     * @param  string $reasonmsg
     * @return void
     */
    public function clientKick($clid, $reasonid = TeamSpeak3::KICK_CHANNEL, $reasonmsg = null)
    {
        $this->clientListReset();

        $this->execute("clientkick", array("clid" => $clid, "reasonid" => $reasonid, "reasonmsg" => $reasonmsg));
    }

    /**
     * Sends a poke message to a client.
     *
     * @param  integer $clid
     * @param  string $msg
     * @return void
     */
    public function clientPoke($clid, $msg)
    {
        $this->execute("clientpoke", array("clid" => $clid, "msg" => $msg));
    }

    /**
     * Bans the client specified with ID $clid from the server. Please note that this will create two separate
     * ban rules for the targeted clients IP address and his unique identifier.
     *
     * @param  integer $clid
     * @param  integer $timeseconds
     * @param  string $reason
     * @return array
     */
    public function clientBan($clid, $timeseconds = null, $reason = null)
    {
        $this->clientListReset();

        $bans = $this->execute(
            "banclient",
            array("clid" => $clid, "time" => $timeseconds, "banreason" => $reason)
        )->toAssocArray("banid");

        return array_keys($bans);
    }

    /**
     * Changes the clients properties using given properties.
     *
     * @param  string $cldbid
     * @param  array $properties
     * @return void
     */
    public function clientModifyDb($cldbid, array $properties)
    {
        $properties["cldbid"] = $cldbid;

        $this->execute("clientdbedit", $properties);
    }

    /**
     * Deletes a clients properties from the database.
     *
     * @param  string $cldbid
     * @return void
     */
    public function clientDeleteDb($cldbid)
    {
        $this->execute("clientdbdelete", array("cldbid" => $cldbid));
    }

    /**
     * Sets the channel group of a client to the ID specified.
     *
     * @param  integer $cldbid
     * @param  integer $cid
     * @param  integer $cgid
     * @return void
     */
    public function clientSetChannelGroup($cldbid, $cid, $cgid)
    {
        $this->execute("setclientchannelgroup", array("cldbid" => $cldbid, "cid" => $cid, "cgid" => $cgid));
    }

    /**
     * Returns a list of permissions defined for a client.
     *
     * @param  integer $cldbid
     * @param  boolean $permsid
     * @return array
     */
    public function clientPermList($cldbid, $permsid = false)
    {
        $this->clientListReset();

        return $this->execute("clientpermlist", array("cldbid" => $cldbid, $permsid ? "-permsid" : null))->toAssocArray(
            $permsid ? "permsid" : "permid"
        );
    }

    /**
     * Adds a set of specified permissions to a client. Multiple permissions can be added by providing
     * the three parameters of each permission.
     *
     * @param  integer $cldbid
     * @param  integer $permid
     * @param  integer $permvalue
     * @param  integer $permskip
     * @return void
     */
    public function clientPermAssign($cldbid, $permid, $permvalue, $permskip = false)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute(
            "clientaddperm",
            array("cldbid" => $cldbid, $permident => $permid, "permvalue" => $permvalue, "permskip" => $permskip)
        );
    }

    /**
     * Removes a set of specified permissions from a client. Multiple permissions can be removed at once.
     *
     * @param integer $cldbid
     * @param integer $permid
     * @return void
     */
    public function clientPermRemove($cldbid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("clientdelperm", array("cldbid" => $cldbid, $permident => $permid));
    }

    /**
     * Returns a list of server groups available.
     *
     * @param  filter $filter
     * @return array
     */
    public function serverGroupList(array $filter = array())
    {
        if ($this->sgroupList === null) {
            $this->sgroupList = $this->request("servergrouplist")->toAssocArray("sgid");

            foreach ($this->sgroupList as $sgid => $group) {
                $this->sgroupList[$sgid] = new Servergroup($this, $group);
            }

            uasort($this->sgroupList, array(__CLASS__, "sortGroupList"));
        }

        return $this->filterList($this->sgroupList, $filter);
    }

    /**
     * Resets the list of server groups.
     *
     * @return void
     */
    public function serverGroupListReset()
    {
        $this->sgroupList = null;
    }

    /**
     * Creates a new server group using the name specified with $name and returns its ID.
     *
     * @param  string $name
     * @param  integer $type
     * @return integer
     */
    public function serverGroupCreate($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->serverGroupListReset();

        $sgid = $this->execute("servergroupadd", array("name" => $name, "type" => $type))->toList();

        return $sgid["sgid"];
    }

    /**
     * Creates a copy of an existing server group specified by $ssgid and returns the new groups ID.
     *
     * @param  integer $ssgid
     * @param  string $name
     * @param  integer $tsgid
     * @param  integer $type
     * @return integer
     */
    public function serverGroupCopy($ssgid, $name = null, $tsgid = 0, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->serverGroupListReset();

        $sgid = $this->execute(
            "servergroupcopy",
            array("ssgid" => $ssgid, "tsgid" => $tsgid, "name" => $name, "type" => $type)
        )->toList();

        if ($tsgid && $name) {
            $this->serverGroupRename($tsgid, $name);
        }

        return count($sgid) ? $sgid["sgid"] : intval($tsgid);
    }

    /**
     * Renames the server group specified with $sgid.
     *
     * @param  integer $sgid
     * @param  string $name
     * @return void
     */
    public function serverGroupRename($sgid, $name)
    {
        $this->serverGroupListReset();

        $this->execute("servergrouprename", array("sgid" => $sgid, "name" => $name));
    }

    /**
     * Deletes the server group specified with $sgid. If $force is set to 1, the server group
     * will be deleted even if there are clients within.
     *
     * @param  integer $sgid
     * @param  boolean $force
     * @return void
     */
    public function serverGroupDelete($sgid, $force = false)
    {
        $this->serverGroupListReset();

        $this->execute("servergroupdel", array("sgid" => $sgid, "force" => $force));
    }

    /**
     * Returns the Servergroup object matching the given ID.
     *
     * @param  integer $sgid
     * @throws Ts3Exception
     * @return Servergroup
     */
    public function serverGroupGetById($sgid)
    {
        if (!array_key_exists((string)$sgid, $this->serverGroupList())) {
            throw new Ts3Exception("invalid groupID", 0xA00);
        }

        return $this->sgroupList[intval((string)$sgid)];
    }

    /**
     * Returns the Servergroup object matching the given name.
     *
     * @param  string $name
     * @param  integer $type
     * @throws Ts3Exception
     * @return Servergroup
     */
    public function serverGroupGetByName($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        foreach ($this->serverGroupList() as $group) {
            if ($group["name"] == $name && $group["type"] == $type) {
                return $group;
            }
        }

        throw new Ts3Exception("invalid groupID", 0xA00);
    }

    /**
     * Returns a list of permissions assigned to the server group specified.
     *
     * @param  integer $sgid
     * @param  boolean $permsid
     * @return array
     */
    public function serverGroupPermList($sgid, $permsid = false)
    {
        return $this->execute(
            "servergrouppermlist",
            array("sgid" => $sgid, $permsid ? "-permsid" : null)
        )->toAssocArray($permsid ? "permsid" : "permid");
    }

    /**
     * Adds a set of specified permissions to the server group specified. Multiple permissions
     * can be added by providing the four parameters of each permission in separate arrays.
     *
     * @param  integer $sgid
     * @param  integer $permid
     * @param  integer $permvalue
     * @param  integer $permnegated
     * @param  integer $permskip
     * @return void
     */
    public function serverGroupPermAssign($sgid, $permid, $permvalue, $permnegated = false, $permskip = false)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute(
            "servergroupaddperm",
            array(
                "sgid" => $sgid,
                $permident => $permid,
                "permvalue" => $permvalue,
                "permnegated" => $permnegated,
                "permskip" => $permskip
            )
        );
    }

    /**
     * Removes a set of specified permissions from the server group specified with $sgid. Multiple
     * permissions can be removed at once.
     *
     * @param  integer $sgid
     * @param  integer $permid
     * @return void
     */
    public function serverGroupPermRemove($sgid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("servergroupdelperm", array("sgid" => $sgid, $permident => $permid));
    }

    /**
     * Returns a list of clients assigned to the server group specified.
     *
     * @param  integer $sgid
     * @return array
     */
    public function serverGroupClientList($sgid)
    {
        if ($this["virtualserver_default_server_group"] == $sgid) {
            return array();
        }

        return $this->execute("servergroupclientlist", array("sgid" => $sgid, "-names"))->toAssocArray("cldbid");
    }

    /**
     * Adds a client to the server group specified. Please note that a client cannot be
     * added to default groups or template groups.
     *
     * @param  integer $sgid
     * @param  integer $cldbid
     * @return void
     */
    public function serverGroupClientAdd($sgid, $cldbid)
    {
        $this->clientListReset();

        $this->execute("servergroupaddclient", array("sgid" => $sgid, "cldbid" => $cldbid));
    }

    /**
     * Removes a client from the server group specified.
     *
     * @param  integer $sgid
     * @param  integer $cldbid
     * @return void
     */
    public function serverGroupClientDel($sgid, $cldbid)
    {
        $this->execute("servergroupdelclient", array("sgid" => $sgid, "cldbid" => $cldbid));
    }

    /**
     * Returns an ordered array of regular server groups available based on a pre-defined
     * set of rules.
     *
     * @return array
     */
    public function serverGroupGetProfiles()
    {
        $profiles = array();

        foreach ($this->serverGroupList() as $sgid => $sgroup) {
            if ($sgroup["type"] != TeamSpeak3::GROUP_DBTYPE_REGULAR) {
                continue;
            }

            $profiles[$sgid] = array(
                "b_permission_modify_power_ignore" => 0,
                "i_group_needed_member_add_power" => 0,
                "i_group_member_add_power" => 0,
                "i_group_needed_member_remove_power" => 0,
                "i_group_member_remove_power" => 0,
                "i_needed_modify_power_count" => 0,
                "i_needed_modify_power_total" => 0,
                "i_permission_modify_power" => 0,
                "i_group_needed_modify_power" => 0,
                "i_group_modify_power" => 0,
                "i_client_needed_modify_power" => 0,
                "i_client_modify_power" => 0,
                "b_virtualserver_servergroup_create" => 0,
                "b_virtualserver_servergroup_delete" => 0,
                "b_client_ignore_bans" => 0,
                "b_client_ignore_antiflood" => 0,
                "b_group_is_permanent" => 0,
                "i_client_needed_ban_power" => 0,
                "i_client_needed_kick_power" => 0,
                "i_client_needed_move_power" => 0,
                "i_client_talk_power" => 0,
                "__sgid" => $sgid,
                "__name" => $sgroup->toString(),
                "__node" => $sgroup,
            );

            try {
                $perms = $this->serverGroupPermList($sgid, true);
                $grant = isset($perms["i_permission_modify_power"]) ? $perms["i_permission_modify_power"]["permvalue"] : null;
            } catch (Ts3Exception $e) {
                /* ERROR_database_empty_result */
                if ($e->getCode() != 0x501) {
                    throw $e;
                }

                $perms = array();
                $grant = null;
            }

            foreach ($perms as $permsid => $perm) {
                if (in_array($permsid, array_keys($profiles[$sgid]))) {
                    $profiles[$sgid][$permsid] = $perm["permvalue"];
                } elseif (StringHelper::factory($permsid)->startsWith("i_needed_modify_power_")) {
                    if (!$grant || $perm["permvalue"] > $grant) {
                        continue;
                    }

                    $profiles[$sgid]["i_needed_modify_power_total"] = $profiles[$sgid]["i_needed_modify_power_total"] + $perm["permvalue"];
                    $profiles[$sgid]["i_needed_modify_power_count"]++;
                }
            }
        }

        array_multisort($profiles, SORT_DESC);

        return $profiles;
    }

    /**
     * Tries to identify the post powerful/weakest server group on the virtual server and returns
     * the ID.
     *
     * @param  integer $mode
     * @return Servergroup
     */
    public function serverGroupIdentify($mode = TeamSpeak3::GROUP_IDENTIFIY_STRONGEST)
    {
        $profiles = $this->serverGroupGetProfiles();

        $best_guess_profile = ($mode == TeamSpeak3::GROUP_IDENTIFIY_STRONGEST) ? array_shift($profiles) : array_pop(
            $profiles
        );

        return $this->serverGroupGetById($best_guess_profile["__sgid"]);
    }

    /**
     * Returns a list of channel groups available.
     *
     * @param  array $filter
     * @return array
     */
    public function channelGroupList(array $filter = array())
    {
        if ($this->cgroupList === null) {
            $this->cgroupList = $this->request("channelgrouplist")->toAssocArray("cgid");

            foreach ($this->cgroupList as $cgid => $group) {
                $this->cgroupList[$cgid] = new Channelgroup($this, $group);
            }

            uasort($this->cgroupList, array(__CLASS__, "sortGroupList"));
        }

        return $this->filterList($this->cgroupList, $filter);
    }

    /**
     * Resets the list of channel groups.
     *
     * @return void
     */
    public function channelGroupListReset()
    {
        $this->cgroupList = null;
    }

    /**
     * Creates a new channel group using the name specified with $name and returns its ID.
     *
     * @param  string $name
     * @param  integer $type
     * @return integer
     */
    public function channelGroupCreate($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->channelGroupListReset();

        $cgid = $this->execute("channelgroupadd", array("name" => $name, "type" => $type))->toList();

        return $cgid["cgid"];
    }

    /**
     * Creates a copy of an existing channel group specified by $scgid and returns the new groups ID.
     *
     * @param  integer $scgid
     * @param  string $name
     * @param  integer $tcgid
     * @param  integer $type
     * @return integer
     */
    public function channelGroupCopy($scgid, $name = null, $tcgid = 0, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        $this->channelGroupListReset();

        $cgid = $this->execute(
            "channelgroupcopy",
            array("scgid" => $scgid, "tcgid" => $tcgid, "name" => $name, "type" => $type)
        )->toList();

        if ($tcgid && $name) {
            $this->channelGroupRename($tcgid, $name);
        }

        return count($cgid) ? $cgid["cgid"] : intval($tcgid);
    }

    /**
     * Renames the channel group specified with $cgid.
     *
     * @param  integer $cgid
     * @param  string $name
     * @return void
     */
    public function channelGroupRename($cgid, $name)
    {
        $this->channelGroupListReset();

        $this->execute("channelgrouprename", array("cgid" => $cgid, "name" => $name));
    }

    /**
     * Deletes the channel group specified with $cgid. If $force is set to 1, the channel group
     * will be deleted even if there are clients within.
     *
     * @param  integer $sgid
     * @param  boolean $force
     * @return void
     */
    public function channelGroupDelete($cgid, $force = false)
    {
        $this->channelGroupListReset();

        $this->execute("channelgroupdel", array("cgid" => $cgid, "force" => $force));
    }

    /**
     * Returns the Channelgroup object matching the given ID.
     *
     * @param  integer $cgid
     * @throws Ts3Exception
     * @return Channelgroup
     */
    public function channelGroupGetById($cgid)
    {
        if (!array_key_exists((string)$cgid, $this->channelGroupList())) {
            throw new Ts3Exception("invalid groupID", 0xA00);
        }

        return $this->cgroupList[intval((string)$cgid)];
    }

    /**
     * Returns the Channelgroup object matching the given name.
     *
     * @param  string $name
     * @param  integer $type
     * @throws Ts3Exception
     * @return Channelgroup
     */
    public function channelGroupGetByName($name, $type = TeamSpeak3::GROUP_DBTYPE_REGULAR)
    {
        foreach ($this->channelGroupList() as $group) {
            if ($group["name"] == $name && $group["type"] == $type) {
                return $group;
            }
        }

        throw new Ts3Exception("invalid groupID", 0xA00);
    }

    /**
     * Returns a list of permissions assigned to the channel group specified.
     *
     * @param  integer $cgid
     * @param  boolean $permsid
     * @return array
     */
    public function channelGroupPermList($cgid, $permsid = false)
    {
        return $this->execute(
            "channelgrouppermlist",
            array("cgid" => $cgid, $permsid ? "-permsid" : null)
        )->toAssocArray($permsid ? "permsid" : "permid");
    }

    /**
     * Adds a set of specified permissions to the channel group specified. Multiple permissions
     * can be added by providing the two parameters of each permission in separate arrays.
     *
     * @param  integer $cgid
     * @param  integer $permid
     * @param  integer $permvalue
     * @return void
     */
    public function channelGroupPermAssign($cgid, $permid, $permvalue)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("channelgroupaddperm", array("cgid" => $cgid, $permident => $permid, "permvalue" => $permvalue));
    }

    /**
     * Removes a set of specified permissions from the channel group specified with $cgid. Multiple
     * permissions can be removed at once.
     *
     * @param  integer $cgid
     * @param  integer $permid
     * @return void
     */
    public function channelGroupPermRemove($cgid, $permid)
    {
        if (!is_array($permid)) {
            $permident = (is_numeric($permid)) ? "permid" : "permsid";
        } else {
            $permident = (is_numeric(current($permid))) ? "permid" : "permsid";
        }

        $this->execute("channelgroupdelperm", array("cgid" => $cgid, $permident => $permid));
    }

    /**
     * Returns all the client and/or channel IDs currently assigned to channel groups. All three
     * parameters are optional so you're free to choose the most suitable combination for your
     * requirements.
     *
     * @param  integer $cgid
     * @param  integer $cid
     * @param  integer $cldbid
     * @return array
     */
    public function channelGroupClientList($cgid = null, $cid = null, $cldbid = null)
    {
        if ($this["virtualserver_default_channel_group"] == $cgid) {
            return array();
        }

        return $this->execute(
            "channelgroupclientlist",
            array("cgid" => $cgid, "cid" => $cid, "cldbid" => $cldbid)
        )->toArray();
    }

    /**
     * Restores the default permission settings on the virtual server and returns a new initial
     * administrator privilege key.
     *
     * @return StringHelper
     */
    public function permReset()
    {
        $token = $this->request("permreset")->toList();

        Signal::getInstance()->emit("notifyTokencreated", $this, $token["token"]);

        return $token["token"];
    }

    /**
     * Removes any assignment of the permission specified with $permid on the selected virtual server
     * and returns the number of removed assignments on success.
     *
     * @param  integer $permid
     * @return integer
     */
    public function permRemoveAny($permid)
    {
        $assignments = $this->permissionFind($permid);

        foreach ($assignments as $assignment) {
            switch ($assignment["t"]) {
                case TeamSpeak3::PERM_TYPE_SERVERGROUP:
                    $this->serverGroupPermRemove($assignment["id1"], $assignment["p"]);
                    break;

                case TeamSpeak3::PERM_TYPE_CLIENT:
                    $this->clientPermRemove($assignment["id2"], $assignment["p"]);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNEL:
                    $this->channelPermRemove($assignment["id2"], $assignment["p"]);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNELGROUP:
                    $this->channelGroupPermRemove($assignment["id1"], $assignment["p"]);
                    break;

                case TeamSpeak3::PERM_TYPE_CHANNELCLIENT:
                    $this->channelClientPermRemove($assignment["id2"], $assignment["id1"], $assignment["p"]);
                    break;

                default:
                    throw new Ts3Exception("convert error", 0x604);
            }
        }

        return count($assignments);
    }

    /**
     * Initializes a file transfer upload. $clientftfid is an arbitrary ID to identify the file transfer on client-side.
     *
     * @param  integer $clientftfid
     * @param  integer $cid
     * @param  string $name
     * @param  integer $size
     * @param  string $cpw
     * @param  boolean $overwrite
     * @param  boolean $resume
     * @throws Ts3Exception
     * @return array
     */
    public function transferInitUpload($clientftfid, $cid, $name, $size, $cpw = "", $overwrite = false, $resume = false)
    {
        $upload = $this->execute(
            "ftinitupload",
            array(
                "clientftfid" => $clientftfid,
                "cid" => $cid,
                "name" => $name,
                "cpw" => $cpw,
                "size" => $size,
                "overwrite" => $overwrite,
                "resume" => $resume
            )
        )->toList();

        if (array_key_exists("status", $upload) && $upload["status"] != 0x00) {
            throw new Ts3Exception($upload["msg"], $upload["status"]);
        }

        $upload["cid"] = $cid;
        $upload["file"] = $name;

        if (!array_key_exists("ip", $upload) || $upload["ip"]->startsWith("0.0.0.0")) {
            $upload["ip"] = $this->getParent()->getAdapterHost();
            $upload["host"] = $upload["ip"];
        } else {
            $upload["ip"] = $upload["ip"]->section(",");
            $upload["host"] = $upload["ip"];
        }

        Signal::getInstance()->emit("filetransferUploadInit", $upload["ftkey"], $upload);

        return $upload;
    }

    /**
     * Initializes a file transfer download. $clientftfid is an arbitrary ID to identify the file transfer on client-side.
     *
     * @param  integer $clientftfid
     * @param  integer $cid
     * @param  string $name
     * @param  string $cpw
     * @param  integer $seekpos
     * @throws Ts3Exception
     * @return array
     */
    public function transferInitDownload($clientftfid, $cid, $name, $cpw = "", $seekpos = 0)
    {
        $download = $this->execute(
            "ftinitdownload",
            array("clientftfid" => $clientftfid, "cid" => $cid, "name" => $name, "cpw" => $cpw, "seekpos" => $seekpos)
        )->toList();

        if (array_key_exists("status", $download) && $download["status"] != 0x00) {
            throw new Ts3Exception($download["msg"], $download["status"]);
        }

        $download["cid"] = $cid;
        $download["file"] = $name;

        if (!array_key_exists("ip", $download) || $download["ip"]->startsWith("0.0.0.0")) {
            $download["ip"] = $this->getParent()->getAdapterHost();
            $download["host"] = $download["ip"];
        } else {
            $download["ip"] = $download["ip"]->section(",");
            $download["host"] = $download["ip"];
        }

        Signal::getInstance()->emit("filetransferDownloadInit", $download["ftkey"], $download);

        return $download;
    }

    /**
     * Displays a list of running file transfers on the selected virtual server. The output contains the path to
     * which a file is uploaded to, the current transfer rate in bytes per second, etc.
     *
     * @return array
     */
    public function transferList()
    {
        return $this->request("ftlist")->toAssocArray("serverftfid");
    }

    /**
     * Stops the running file transfer with server-side ID $serverftfid.
     *
     * @param  integer $serverftfid
     * @param  boolean $delete
     * @return void
     */
    public function transferStop($serverftfid, $delete = false)
    {
        $this->execute("ftstop", array("serverftfid" => $serverftfid, "delete" => $delete));
    }

    /**
     * Downloads and returns the servers icon file content.
     *
     * @return StringHelper
     */
    public function iconDownload()
    {
        if ($this->iconIsLocal("virtualserver_icon_id") || $this["virtualserver_icon_id"] == 0) {
            return;
        }

        $download = $this->transferInitDownload(rand(0x0000, 0xFFFF), 0, $this->iconGetName("virtualserver_icon_id"));
        $transfer = TeamSpeak3::factory("filetransfer://" . $download["host"] . ":" . $download["port"]);

        return $transfer->download($download["ftkey"], $download["size"]);
    }

    /**
     * Uploads a given icon file content to the server and returns the ID of the icon.
     *
     * @param  string $data
     * @return integer
     */
    public function iconUpload($data)
    {
        $crc = crc32($data);
        $size = strlen($data);

        $upload = $this->transferInitUpload(rand(0x0000, 0xFFFF), 0, "/icon_" . $crc, $size);
        $transfer = TeamSpeak3::factory("filetransfer://" . $upload["host"] . ":" . $upload["port"]);

        $transfer->upload($upload["ftkey"], $upload["seekpos"], $data);

        return $crc;
    }

    /**
     * Changes the virtual server configuration using given properties.
     *
     * @param  array $properties
     * @return void
     */
    public function modify(array $properties)
    {
        $this->execute("serveredit", $properties);
        $this->resetNodeInfo();
    }

    /**
     * Sends a text message to all clients on the virtual server.
     *
     * @param  string $msg
     * @return void
     */
    public function message($msg)
    {
        $this->execute(
            "sendtextmessage",
            array("msg" => $msg, "target" => $this->getId(), "targetmode" => TeamSpeak3::TEXTMSG_SERVER)
        );
    }

    /**
     * Returns a list of offline messages you've received. The output contains the senders unique identifier,
     * the messages subject, etc.
     *
     * @return array
     */
    public function messageList()
    {
        return $this->request("messagelist")->toAssocArray("msgid");
    }

    /**
     * Sends an offline message to the client specified by $cluid.
     *
     * @param  string $cluid
     * @param  string $subject
     * @param  string $message
     * @return void
     */
    public function messageCreate($cluid, $subject, $message)
    {
        $this->execute("messageadd", array("cluid" => $cluid, "subject" => $subject, "message" => $message));
    }

    /**
     * Deletes an existing offline message with ID $msgid from your inbox.
     *
     * @param  integer $msgid
     * @return void
     */
    public function messageDelete($msgid)
    {
        $this->execute("messagedel", array("msgid" => $msgid));
    }

    /**
     * Returns an existing offline message with ID $msgid from your inbox.
     *
     * @param  integer $msgid
     * @param  boolean $flag_read
     * @return array
     */
    public function messageRead($msgid, $flag_read = true)
    {
        $msg = $this->execute("messageget", array("msgid" => $msgid))->toList();

        if ($flag_read) {
            $this->execute("messageget", array("msgid" => $msgid, "flag" => $flag_read));
        }

        return $msg;
    }

    /**
     * Creates and returns snapshot data for the selected virtual server.
     *
     * @param  string $mode
     * @return string
     */
    public function snapshotCreate($mode = TeamSpeak3::SNAPSHOT_STRING)
    {
        $snapshot = $this->request("serversnapshotcreate")->toString(false);

        switch ($mode) {
            case TeamSpeak3::SNAPSHOT_BASE64:
                return $snapshot->toBase64();
                break;

            case TeamSpeak3::SNAPSHOT_HEXDEC:
                return $snapshot->toHex();
                break;

            default:
                return (string)$snapshot;
                break;
        }
    }

    /**
     * Deploys snapshot data on the selected virtual server. If no virtual server is selected (ID 0),
     * the data will be used to create a new virtual server from scratch.
     *
     * @param  string $data
     * @param  string $mode
     * @return array
     */
    public function snapshotDeploy($data, $mode = TeamSpeak3::SNAPSHOT_STRING)
    {
        switch ($mode) {
            case TeamSpeak3::SNAPSHOT_BASE64:
                $data = StringHelper::fromBase64($data);
                break;

            case TeamSpeak3::SNAPSHOT_HEXDEC:
                $data = StringHelper::fromHex($data);
                break;

            default:
                $data = StringHelper::factory($data);
                break;
        }

        $detail = $this->request("serversnapshotdeploy " . $data)->toList();

        if (array_key_exists("sid", $detail)) {
            Signal::getInstance()->emit("notifyServercreated", $this->getParent(), $detail["sid"]);
        }

        return $detail;
    }

    /**
     * Registers for a specified category of events on a virtual server to receive notification
     * messages. Depending on the notifications you've registered for, the server will send you
     * a message on every event.
     *
     * @param  string $event
     * @param  integer $id
     * @return void
     */
    public function notifyRegister($event, $id = 0)
    {
        $this->execute("servernotifyregister", array("event" => $event, "id" => $id));
    }

    /**
     * Unregisters all events previously registered with servernotifyregister so you will no
     * longer receive notification messages.
     *
     * @return void
     */
    public function notifyUnregister()
    {
        $this->request("servernotifyunregister");
    }

    /**
     * Alias for privilegeKeyList().
     *
     * @deprecated
     */
    public function tokenList($translate = false)
    {
        return $this->privilegeKeyList();
    }

    /**
     * Returns a list of privilege keys (tokens) available. If $resolve is set to TRUE the values
     * of token_id1 and token_id2 will be translated into the appropriate group and/or channel
     * names.
     *
     * @param  boolean $resolve
     * @return array
     */
    public function privilegeKeyList($resolve = false)
    {
        $tokens = $this->request("privilegekeylist")->toAssocArray("token");

        if ($resolve) {
            foreach ($tokens as $token => $array) {
                $func = $array["token_type"] ? "channelGroupGetById" : "serverGroupGetById";

                try {
                    $tokens[$token]["token_id1"] = $this->$func($array["token_id1"])->name;
                } catch (Ts3Exception $e) {
                    /* ERROR_channel_invalid_id */
                    if ($e->getCode() != 0xA00) {
                        throw $e;
                    }
                }

                try {
                    if ($array["token_type"]) {
                        $tokens[$token]["token_id2"] = $this->channelGetById(
                            $array["token_id2"]
                        )->getPathway();
                    }
                } catch (Ts3Exception $e) {
                    /* ERROR_permission_invalid_group_id */
                    if ($e->getCode() != 0x300) {
                        throw $e;
                    }
                }
            }
        }

        return $tokens;
    }

    /**
     * Alias for privilegeKeyCreate().
     *
     * @deprecated
     */
    public function tokenCreate(
        $type = TeamSpeak3::TOKEN_SERVERGROUP,
        $id1,
        $id2 = 0,
        $description = null,
        $customset = null
    ) {
        return $this->privilegeKeyCreate($type, $id1, $id2, $description, $customset);
    }

    /**
     * Creates a new privilege key (token) and returns the key.
     *
     * @param  integer $type
     * @param  integer $id1
     * @param  integer $id2
     * @param  string $description
     * @param  string $customset
     * @return StringHelper
     */
    public function privilegeKeyCreate(
        $type = TeamSpeak3::TOKEN_SERVERGROUP,
        $id1,
        $id2 = 0,
        $description = null,
        $customset = null
    ) {
        $token = $this->execute(
            "privilegekeyadd",
            array(
                "tokentype" => $type,
                "tokenid1" => $id1,
                "tokenid2" => $id2,
                "tokendescription" => $description,
                "tokencustomset" => $customset
            )
        )->toList();

        Signal::getInstance()->emit("notifyTokencreated", $this, $token["token"]);

        return $token["token"];
    }

    /**
     * Alias for privilegeKeyDelete().
     *
     * @deprecated
     */
    public function tokenDelete($token)
    {
        $this->privilegeKeyDelete($token);
    }

    /**
     * Deletes a token specified by key $token.
     *
     * @param  string $token
     * @return void
     */
    public function privilegeKeyDelete($token)
    {
        $this->execute("privilegekeydelete", array("token" => $token));
    }

    /**
     * Alias for privilegeKeyUse().
     *
     * @deprecated
     */
    public function tokenUse($token)
    {
        $this->privilegeKeyUse($token);
    }

    /**
     * Use a token key gain access to a server or channel group. Please note that the server will
     * automatically delete the token after it has been used.
     *
     * @param  string $token
     * @return void
     */
    public function privilegeKeyUse($token)
    {
        $this->execute("privilegekeyuse", array("token" => $token));
    }

    /**
     * Returns a list of custom client properties specified by $ident.
     *
     * @param  string $ident
     * @param  string $pattern
     * @return array
     */
    public function customSearch($ident, $pattern = "%")
    {
        return $this->execute("customsearch", array("ident" => $ident, "pattern" => $pattern))->toArray();
    }

    /**
     * Returns a list of custom properties for the client specified by $cldbid.
     *
     * @param  integer $cldbid
     * @return array
     */
    public function customInfo($cldbid)
    {
        return $this->execute("custominfo", array("cldbid" => $cldbid))->toArray();
    }

    /**
     * Returns a list of active bans on the selected virtual server.
     *
     * @return array
     */
    public function banList()
    {
        return $this->request("banlist")->toAssocArray("banid");
    }

    /**
     * Deletes all active ban rules from the server.
     *
     * @return void
     */
    public function banListClear()
    {
        $this->request("bandelall");
    }

    /**
     * Adds a new ban rule on the selected virtual server. All parameters are optional but at least one
     * of the following rules must be set: ip, name, or uid.
     *
     * @param  array $rules
     * @param  integer $timeseconds
     * @param  string $reason
     * @return integer
     */
    public function banCreate(array $rules, $timeseconds = null, $reason = null)
    {
        $rules["time"] = $timeseconds;
        $rules["banreason"] = $reason;

        $banid = $this->execute("banadd", $rules)->toList();

        return $banid["banid"];
    }

    /**
     * Deletes the specified ban rule from the server.
     *
     * @param  integer $banid
     * @return void
     */
    public function banDelete($banid)
    {
        $this->execute("bandel", array("banid" => $banid));
    }

    /**
     * Returns a list of complaints on the selected virtual server. If $tcldbid is specified, only
     * complaints about the targeted client will be shown.
     *
     * @param  integer $tcldbid
     * @return array
     */
    public function complaintList($tcldbid = null)
    {
        return $this->execute("complainlist", array("tcldbid" => $tcldbid))->toArray();
    }

    /**
     * Deletes all active complaints about the client with database ID $tcldbid from the server.
     *
     * @param  integer $tcldbid
     * @return void
     */
    public function complaintListClear($tcldbid)
    {
        $this->execute("complaindelall", array("tcldbid" => $tcldbid));
    }

    /**
     * Submits a complaint about the client with database ID $tcldbid to the server.
     *
     * @param  integer $tcldbid
     * @param  string $message
     * @return void
     */
    public function complaintCreate($tcldbid, $message)
    {
        $this->execute("complainadd", array("tcldbid" => $tcldbid, "message" => $message));
    }

    /**
     * Deletes the complaint about the client with ID $tcldbid submitted by the client with ID $fcldbid from the server.
     *
     * @param  integer $tcldbid
     * @param  integer $fcldbid
     * @return void
     */
    public function complaintDelete($tcldbid, $fcldbid)
    {
        $this->execute("complaindel", array("tcldbid" => $tcldbid, "fcldbid" => $fcldbid));
    }

    /**
     * Returns a list of temporary server passwords.
     *
     * @param  boolean $resolve
     * @return array
     */
    public function tempPasswordList($resolve = false)
    {
        $passwords = $this->request("servertemppasswordlist")->toAssocArray("pw_clear");

        if ($resolve) {
            foreach ($passwords as $password => $array) {
                try {
                    $channel = $this->channelGetById($array["tcid"]);

                    $passwords[$password]["tcname"] = $channel->toString();
                    $passwords[$password]["tcpath"] = $channel->getPathway();
                } catch (Ts3Exception $e) {
                    /* ERROR_channel_invalid_id */
                    if ($e->getCode() != 0xA00) {
                        throw $e;
                    }
                }
            }
        }

        return $passwords;
    }

    /**
     * Sets a new temporary server password specified with $pw. The temporary password will be
     * valid for the number of seconds specified with $duration. The client connecting with this
     * password will automatically join the channel specified with $tcid. If tcid is set to 0,
     * the client will join the default channel.
     *
     * @param  string $pw
     * @param  integer $duration
     * @param  integer $tcid
     * @param  string $tcpw
     * @param  string $desc
     * @return void
     */
    public function tempPasswordCreate($pw, $duration, $tcid = 0, $tcpw = "", $desc = "")
    {
        $this->execute(
            "servertemppasswordadd",
            array("pw" => $pw, "duration" => $duration, "tcid" => $tcid, "tcpw" => $tcpw, "desc" => $desc)
        );
    }

    /**
     * Deletes the temporary server password specified with $pw.
     *
     * @param  string $pw
     * @return void
     */
    public function tempPasswordDelete($pw)
    {
        $this->execute("servertemppassworddel", array("pw" => $pw));
    }

    /**
     * Displays a specified number of entries (1-100) from the servers log.
     *
     * @param  integer $lines
     * @param  integer $begin_pos
     * @param  boolean $reverse
     * @param  boolean $instance
     * @return array
     */
    public function logView($lines = 30, $begin_pos = null, $reverse = null, $instance = null)
    {
        return $this->execute(
            "logview",
            array("lines" => $lines, "begin_pos" => $begin_pos, "instance" => $instance, "reverse" => $reverse)
        )->toArray();
    }

    /**
     * Writes a custom entry into the virtual server log.
     *
     * @param  string $logmsg
     * @param  integer $loglevel
     * @return void
     */
    public function logAdd($logmsg, $loglevel = TeamSpeak3::LOGLEVEL_INFO)
    {
        $this->execute("logadd", array("logmsg" => $logmsg, "loglevel" => $loglevel));
    }

    /**
     * Returns detailed connection information of the virtual server.
     *
     * @return array
     */
    public function connectionInfo()
    {
        return $this->request("serverrequestconnectioninfo")->toList();
    }

    /**
     * Deletes the virtual server.
     *
     * @return void
     */
    public function delete()
    {
        $this->getParent()->serverDelete($this->getId());
    }

    /**
     * Starts the virtual server.
     *
     * @return void
     */
    public function start()
    {
        $this->getParent()->serverStart($this->getId());
    }

    /**
     * Stops the virtual server.
     *
     * @return void
     */
    public function stop()
    {
        $this->getParent()->serverStop($this->getId());
    }

    /**
     * Sends a plugin command to all clients connected to the server.
     *
     * @param  string $plugin
     * @param  string $data
     * @return void
     */
    public function sendPluginCmd($plugin, $data)
    {
        $this->execute(
            "plugincmd",
            array("name" => $plugin, "data" => $data, "targetmode" => TeamSpeak3::PLUGINCMD_SERVER)
        );
    }

    /**
     * Changes the properties of your own client connection.
     *
     * @param  array $properties
     * @return void
     */
    public function selfUpdate(array $properties)
    {
        $this->execute("clientupdate", $properties);

        foreach ($properties as $ident => $value) {
            $this->whoamiSet($ident, $value);
        }
    }

    /**
     * Updates your own ServerQuery login credentials using a specified username. The password
     * will be auto-generated.
     *
     * @param  string $username
     * @return StringHelper
     */
    public function selfUpdateLogin($username)
    {
        $password = $this->execute("clientsetserverquerylogin", array("client_login_name" => $username))->toList();

        return $password["client_login_password"];
    }

    /**
     * Returns an array containing the permission overview of your own client.
     *
     * @return array
     */
    public function selfPermOverview()
    {
        return $this->execute(
            "permoverview",
            array(
                "cldbid" => $this->whoamiGet("client_database_id"),
                "cid" => $this->whoamiGet("client_channel_id"),
                "permid" => 0
            )
        )->toArray();
    }

    /**
     * @ignore
     */
    protected function fetchNodeList()
    {
        $this->nodeList = array();

        foreach ($this->channelList() as $channel) {
            if ($channel["pid"] == 0) {
                $this->nodeList[] = $channel;
            }
        }
    }

    /**
     * @ignore
     */
    protected function fetchNodeInfo()
    {
        $this->nodeInfo = array_merge($this->nodeInfo, $this->request("serverinfo")->toList());
    }

    /**
     * Internal callback funtion for sorting of client objects.
     *
     * @param  Client $a
     * @param  Client $b
     * @return integer
     */
    protected static function sortClientList(Client $a, Client $b)
    {
        if (get_class($a) != get_class($b)) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new Ts3Exception("invalid parameter", 0x602);
        }

        if (!$a instanceof Client) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new Ts3Exception("convert error", 0x604);
        }

        if ($a->getProperty("client_talk_power", 0) != $b->getProperty("client_talk_power", 0)) {
            return ($a->getProperty("client_talk_power", 0) > $b->getProperty("client_talk_power", 0)) ? -1 : 1;
        }

        if ($a->getProperty("client_is_talker", 0) != $b->getProperty("client_is_talker", 0)) {
            return ($a->getProperty("client_is_talker", 0) > $b->getProperty("client_is_talker", 0)) ? -1 : 1;
        }

        return strcmp(strtolower($a["client_nickname"]), strtolower($b["client_nickname"]));
    }

    /**
     * Internal callback funtion for sorting of group objects.
     *
     * @param  AbstractNode $a
     * @param  AbstractNode $b
     * @return integer
     */
    protected static function sortGroupList(AbstractNode $a, AbstractNode $b)
    {
        if (get_class($a) != get_class($b)) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new Ts3Exception("invalid parameter", 0x602);
        }

        if (!$a instanceof Servergroup && !$a instanceof Channelgroup) {
            return 0;

            /* workaround for PHP bug #50688 */
            throw new Ts3Exception("convert error", 0x604);
        }

        if ($a->getProperty("sortid", 0) != $b->getProperty("sortid", 0) && $a->getProperty(
                "sortid",
                0
            ) != 0 && $b->getProperty("sortid", 0) != 0
        ) {
            return ($a->getProperty("sortid", 0) < $b->getProperty("sortid", 0)) ? -1 : 1;
        }

        return ($a->getId() < $b->getId()) ? -1 : 1;
    }

    /**
     * Internal callback funtion for sorting of file list items.
     *
     * @param  array $a
     * @param  array $b
     * @throws \Teamspeak3\Ts3Exception
     * @return integer
     */
    protected static function sortFileList(array $a, array $b)
    {
        if (!array_key_exists("src", $a) || !array_key_exists("src", $b) || !array_key_exists(
                "type",
                $a
            ) || !array_key_exists("type", $b)
        ) {
            return 0;

            throw new Ts3Exception("invalid parameter", 0x602);
        }

        if ($a["type"] != $b["type"]) {
            return ($a["type"] < $b["type"]) ? -1 : 1;
        }

        return strcmp(strtolower($a["src"]), strtolower($b["src"]));
    }

    /**
     * Returns TRUE if the virtual server is online.
     *
     * @return boolean
     */
    public function isOnline()
    {
        return ($this["virtualserver_status"] == "online") ? true : false;
    }

    /**
     * Returns TRUE if the virtual server is offline.
     *
     * @return boolean
     */
    public function isOffline()
    {
        return ($this["virtualserver_status"] == "offline") ? true : false;
    }

    /**
     * Returns a unique identifier for the node which can be used as a HTML property.
     *
     * @return string
     */
    public function getUniqueId()
    {
        return $this->getParent()->getUniqueId() . "_s" . $this->getId();
    }

    /**
     * Returns the name of a possible icon to display the node object.
     *
     * @return string
     */
    public function getIcon()
    {
        if ($this["virtualserver_clientsonline"] - $this["virtualserver_queryclientsonline"] >= $this["virtualserver_maxclients"]) {
            return "server_full";
        } elseif ($this["virtualserver_flag_password"]) {
            return "server_pass";
        } else {
            return "server_open";
        }
    }

    /**
     * Returns a symbol representing the node.
     *
     * @return string
     */
    public function getSymbol()
    {
        return "$";
    }

    /**
     * Returns a string representation of this node.
     *
     * @return string
     */
    public function __toString()
    {
        return (string)$this["virtualserver_name"];
    }
}


<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\grid;

use Yii;
use Closure;
use yii\helpers\Html;
use yii\helpers\Url;
use common\component\AppActiveRecord;

/**
 * ActionColumn is a column for the [[GridView]] widget that displays buttons for viewing and manipulating the items.
 *
 * To add an ActionColumn to the gridview, add it to the [[GridView::columns|columns]] configuration as follows:
 *
 * ```php
 * 'columns' => [
 *     // ...
 *     [
 *         'class' => 'yii\grid\ActionColumn',
 *         // you may configure additional properties here
 *     ],
 * ]
 * ```
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
 * @since 2.0
 */
class ActionColumn extends Column
{
    /**
     * @var string the ID of the controller that should handle the actions specified here.
     * If not set, it will use the currently active controller. This property is mainly used by
     * [[urlCreator]] to create URLs for different actions. The value of this property will be prefixed
     * to each action name to form the route of the action.
     */
    public $controller;
    /**
     * @var string the template used for composing each cell in the action column.
     * Tokens enclosed within curly brackets are treated as controller action IDs (also called *button names*
     * in the context of action column). They will be replaced by the corresponding button rendering callbacks
     * specified in [[buttons]]. For example, the token `{view}` will be replaced by the result of
     * the callback `buttons['view']`. If a callback cannot be found, the token will be replaced with an empty string.
     * @see buttons
     */
    public $template = '{view} {update} {delete}';
    /**
     * @var array button rendering callbacks. The array keys are the button names (without curly brackets),
     * and the values are the corresponding button rendering callbacks. The callbacks should use the following
     * signature:
     *
     * ```php
     * function ($url, $model) {
     *     // return the button HTML code
     * }
     * ```
     *
     * where `$url` is the URL that the column creates for the button, and `$model` is the model object
     * being rendered for the current row.
     *
     * You can add further conditions to the button, for example only display it, when the model is
     * editable (here assuming you have a status field that indicates that):
     *
     * ```php
     * [
     *     'update' => function ($url, $model) {
     *         return $model->status == 'editable' ? Html::a('Update', $url) : '';
     *     };
     * ],
     * ```
     */
    public $buttons = [];
    /**
     * @var callable a callback that creates a button URL using the specified model information.
     * The signature of the callback should be the same as that of [[createUrl()]].
     * If this property is not set, button URLs will be created using [[createUrl()]].
     */
    public $urlCreator;

    /**
     * @var callback a callback that check access of that button creation.     *
     *
     */
    public $checkaccess;

    /**
     * @inheritdoc
     */
    public function init()
    {
        parent::init();
        $this->contentOptions = array_merge($this->contentOptions,['width'=>90]);
        $this->initDefaultButtons();

        if(!$this->checkaccess){
            $this->checkaccess = function($url){
                return true;
            };
        }
    }

    /**
     * Initializes the default button rendering callbacks
     */
    protected function initDefaultButtons()
    {
        if (!isset($this->buttons['view'])) {
            $this->buttons['view'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'View'), $url, [
                    'title' => Yii::t('yii', 'View'),
                    'data-pjax' => '0',
                ]));
            };
        }
        if (!isset($this->buttons['update'])) {
            $this->buttons['update'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Edit'), $url, [
                    'title' => Yii::t('yii', 'Edit'),
                    'data-pjax' => '0',
                ]));
            };
        }
        if (!isset($this->buttons['delete'])) {
            $this->buttons['delete'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Delete'), $url, [
                    'title' => Yii::t('yii', 'Delete'),
                    'data-confirm' => Yii::t('yii', 'Are you sure you want to delete this item?'),
                    'data-method' => 'post',
                    'data-pjax' => '0',
                ]));
            };
        }

        if (!isset($this->buttons['restore'])) {
            $this->buttons['restore'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Restore'), $url, [
                    'title' => Yii::t('yii', 'Restore'),
                    'data-pjax' => '0',
                ]));
            };
        }

        if (!isset($this->buttons['setpassword'])) {
            $this->buttons['setpassword'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Set Password'), $url, [
                    'title' => Yii::t('yii', 'Set Password'),
                    'data-pjax' => '0',
                ]));
            };
        }

        if (!isset($this->buttons['changepass'])) {
            $this->buttons['changepass'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Change Password'), $url, [
                    'title' => Yii::t('yii', 'Change Password'),
                    'data-pjax' => '0',
                ]));
            };
        }

        if (!isset($this->buttons['publish'])) {
            $this->buttons['publish'] = function ($url, $model) {
                if($model->state != AppActiveRecord::STATUS_PUBLISH){
                    return Html::tag('li',Html::a(' '.Yii::t('yii', 'Publish'), $url, [
                        'title' => Yii::t('yii', 'Publish'),
                        'data-pjax' => '0',
                        'data-method' => 'post',
                    ]));
                }else{
                    return '';
                }
            };
        }

        if (!isset($this->buttons['unpublish'])) {
            $this->buttons['unpublish'] = function ($url, $model) {
                if($model->state != AppActiveRecord::STATUS_UNPUBLISH){
                    return Html::tag('li',Html::a(' '.Yii::t('yii', 'Unpublish'), $url, [
                        'title' => Yii::t('yii', 'Unpublish'),
                        'data-pjax' => '0',
                        'data-method' => 'post',
                    ]));
                }else{
                    return '';
                }
            };
        }

        if (!isset($this->buttons['sendtopublish'])) {
            $this->buttons['sendtopublish'] = function ($url, $model) {
                if($model->state != AppActiveRecord::STATUS_PUBLISHREADY){
                    return Html::tag('li',Html::a(' '.Yii::t('yii', 'Ready to be Publish'), $url, [
                        'title' => Yii::t('yii', 'Ready to be Publish'),
                        'data-pjax' => '0',
                        'data-method' => 'post',
                    ]));
                }else{
                    return '';
                }
            };
        }
        if (!isset($this->buttons['deallocate'])) {
            $this->buttons['deallocate'] = function ($url, $model) {
                return Html::tag('li',Html::a(' '.Yii::t('yii', 'Deallocate'), $url, [
                    'title' => Yii::t('yii', 'Deallocate'),
                    'data-pjax' => '0',
                ]));
            };
        }
    }

    /**
     * Creates a URL for the given action and model.
     * This method is called for each button and each row.
     * @param string $action the button name (or action ID)
     * @param \yii\db\ActiveRecord $model the data model
     * @param mixed $key the key associated with the data model
     * @param integer $index the current row index
     * @return string the created URL
     */
    public function createUrl($action, $model, $key, $index)
    {
        if ($this->urlCreator instanceof Closure) {
            return call_user_func($this->urlCreator, $action, $model, $key, $index);
        } else {
            $params = is_array($key) ? $key : ['id' => (string) $key];
            $params[0] = $this->controller ? $this->controller . '/' . $action : $action;

            return Url::toRoute($params);
        }
    }

    /**
     * @inheritdoc
     */
    protected function renderDataCellContent($model, $key, $index)
    {
        $content = Html::tag('button','Actions ',[
                    'type'  => 'button',
                    'class' => 'btn btn-default dropdown-toggle',
                    'data-toggle' => 'dropdown',
                ]);

        $buttons = preg_replace_callback('/\\{([\w\-\/]+)\\}/', function ($matches) use ($model, $key, $index) {
            $name = $matches[1];
            $module = \Yii::$app->user->can(\Yii::$app->controller->module->id.'/'.\Yii::$app->controller->id.'/'.$name);
            if($module){
                if (isset($this->buttons[$name])) {
                    $url = $this->createUrl($name, $model, $key, $index);
                    if(call_user_func($this->checkaccess, $url)){
                        return call_user_func($this->buttons[$name], $url, $model);
                    }
                    else{
                        return '';
                    }
               }
            else {
                    return '';
                }
            }
        }, $this->template);

        if($buttons =='' || $buttons ==' '){
            return $buttons;
        }
        $content .= Html::tag('ul',$buttons,[
                    'class' => 'dropdown-menu pull-right',
                    'role' => 'menu',
                ]);

        return Html::tag('div',$content, [
                    'class' => 'dropdown'
                ]);
    }
}


<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\adminUi\widget;

use yii\base\InvalidConfigException;
use yii\helpers\ArrayHelper;
use yii\helpers\Html;

/**
 * Collapse renders an accordion bootstrap javascript component.
 *
 * For example:
 *
 * ```php
 * echo Collapse::widget([
 *     'items' => [
 *         // equivalent to the above
 *         'Collapsible Group Item #1' => [
 *             'content' => 'Anim pariatur cliche...',
 *             // open its content by default
 *             'contentOptions' => ['class' => 'in']
 *         ],
 *         // another group item
 *         'Collapsible Group Item #2' => [
 *             'content' => 'Anim pariatur cliche...',
 *             'contentOptions' => [...],
 *             'options' => [...],
 *         ],
 *     ]
 * ]);
 * ```
 *
 * @see http://getbootstrap.com/javascript/#collapse
 * @author Antonio Ramirez <amigo.cobos@gmail.com>
 * @since 2.0
 */
class Collapse extends Widget
{
    /**
     * @var array list of groups in the collapse widget. Each array element represents a single
     * group with the following structure:
     *
     * ```php
     * // item key is the actual group header
     * 'Collapsible Group Item #1' => [
     *     // required, the content (HTML) of the group
     *     'content' => 'Anim pariatur cliche...',
     *     // optional the HTML attributes of the content group
     *     'contentOptions' => [],
     *     // optional the HTML attributes of the group
     *     'options' => [],
     * ]
     * ```
     */
    public $items = [];

    public $box = false;

    public $header = true;

    /**
     * Initializes the widget.
     */
    public function init()
    {
        parent::init();
        Html::addCssClass($this->options, ($this->box) ? 'box-group' : 'panel-group');
    }

    /**
     * Renders the widget.
     */
    public function run()
    {
        echo Html::beginTag('div', $this->options) . "\n";
        echo $this->renderItems() . "\n";
        echo Html::endTag('div') . "\n";
        $this->registerPlugin('collapse');
    }

    /**
     * Renders collapsible items as specified on [[items]].
     * @return string the rendering result
     */
    public function renderItems()
    {
        $items = [];
        $index = 0;
        foreach ($this->items as $header => $item) {
            $options = ArrayHelper::getValue($item, 'options', []);
            Html::addCssClass($options, ($this->box) ? 'panel box' : 'panel' );
            $items[] = Html::tag('div', $this->renderItem($header, $item, ++$index), $options);
        }

        return implode("\n", $items);
    }

    /**
     * Renders a single collapsible item group
     * @param string $header a label of the item group [[items]]
     * @param array $item a single item from [[items]]
     * @param integer $index the item index as each item group content must have an id
     * @return string the rendering result
     * @throws InvalidConfigException
     */
    public function renderItem($header, $item, $index)
    {
        if (isset($item['content'])) {
            $options = ArrayHelper::getValue($item, 'contentOptions', []);

            if($this->header){
                $id = $this->options['id'] . '-collapse' . $index;
                $options['id'] = $id;
            }else if(!isset($options['id'])){
                throw new InvalidConfigException('ContentOptions "id" need to be specify.');
            }

            Html::addCssClass($options, 'panel-collapse collapse');

            if($this->header){
				$headerToggle = Html::a($header, '#' . $id, [
                    'class' => 'collapse-toggle',
                    'data-toggle' => 'collapse',
                    'data-parent' => '#' . $this->options['id']
                ]) . "\n";
                $header = Html::tag('h4', $headerToggle, ['class' => ($this->box) ? 'box-title' : 'panel-title']);
            }
            $content = Html::tag('div', $item['content'], ['class' => ($this->box) ? 'box-body' : 'panel-body']) . "\n";
        } else {
            throw new InvalidConfigException('The "content" option is required.');
        }
        $group = [];
        if($this->header){
            $group[] = Html::tag('div', $header, ['class' => ($this->box) ? 'box-header' : 'panel-heading']);
        }
        $group[] = Html::tag('div', $content, $options);

        return implode("\n", $group);
    }
}


<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\adminUi\widget;

use Yii;
use yii\adminUi\assetsBundle\AdminUiAsset as AdminUiAsset;
use yii\helpers\ArrayHelper;
use yii\helpers\Html;

/**
 * NavBar renders a navbar HTML component.
 *
 * Any content enclosed between the [[begin()]] and [[end()]] calls of NavBar
 * is treated as the content of the navbar. You may use widgets such as [[Nav]]
 * or [[\yii\widgets\Menu]] to build up such content. For example,
 *
 * ```php
 * use yii\bootstrap\NavBar;
 * use yii\widgets\Menu;
 *
 * NavBar::begin(['brandLabel' => 'NavBar Test']);
 * echo Nav::widget([
 *     'items' => [
 *         ['label' => 'Home', 'url' => ['/site/index']],
 *         ['label' => 'About', 'url' => ['/site/about']],
 *     ],
 * ]);
 * NavBar::end();
 * ```
 *
 * @see http://getbootstrap.com/components/#navbar
 * @author Antonio Ramirez <amigo.cobos@gmail.com>
 * @author Alexander Kochetov <creocoder@gmail.com>
 * @since 2.0
 */
class NavBar extends Widget
{
    /**
     * @var array the HTML attributes for the widget container tag. The following special options are recognized:
     *
     * - tag: string, defaults to "nav", the name of the container tag.
     *
     * @see \yii\helpers\Html::renderTagAttributes() for details on how attributes are being rendered.
     */
    public $options = [];
    /**
     * @var array the HTML attributes for the container tag. The following special options are recognized:
     *
     * - tag: string, defaults to "div", the name of the container tag.
     *
     * @see \yii\helpers\Html::renderTagAttributes() for details on how attributes are being rendered.
     */
    public $containerOptions = [];
    /**
     * @var string text to show for screen readers for the button to toggle the navbar.
     */
    public $screenReaderToggleText = 'Toggle navigation';
    /**
     * @var boolean whether the navbar content should be included in an inner div container which by default
     * adds left and right padding. Set this to false for a 100% width navbar.
     */
    public $renderInnerContainer = false;
    /**
     * @var array the HTML attributes of the inner container.
     * @see \yii\helpers\Html::renderTagAttributes() for details on how attributes are being rendered.
     */
    public $innerContainerOptions = [];

    /**
     * Initializes the widget.
     */
    public function init()
    {
        parent::init();
        $this->clientOptions = false;
        Html::addCssClass($this->options, 'navbar');
        if ($this->options['class'] === 'navbar') {
            Html::addCssClass($this->options, 'navbar-default');
        }

        if (empty($this->options['role'])) {
            $this->options['role'] = 'navigation';
        }
        $options = $this->options;
        $tag = ArrayHelper::remove($options, 'tag', 'nav');
        echo Html::beginTag($tag, $options);
        echo $this->renderToggleButton();
        echo Html::beginTag('div', ['class' => 'navbar-right']);
    }

    /**
     * Renders the widget.
     */
    public function run()
    {
        echo Html::endTag('div');
        $tag = ArrayHelper::remove($this->options, 'tag', 'nav');
        echo Html::endTag($tag);
        AdminUiAsset::register($this->getView());
    }

    /**
     * Renders collapsible toggle button.
     * @return string the rendering toggle button.
     */
    protected function renderToggleButton()
    {
        $screenReader = "{$this->screenReaderToggleText}";
        $screenReader .= "";
        $screenReader .= "";
        $screenReader .= "";

        return Html::tag('a',"{$screenReader}", [
            'class' => 'navbar-btn sidebar-toggle',
            'data-toggle'=> 'offcanvas',
            'role'=>'button']
        );
    }
}