object NewToken(RestVerbs verbs, IParameterCollection parameters)
        {
            var user = verbs["username"];
            var pass = verbs["password"];

            RestObject obj = null;
            if (Verify != null)
                obj = Verify(user, pass);

            if (obj == null)
                obj = new RestObject("401") { Error = "Invalid username/password combination provided. Please re-submit your query with a correct pair." };

            if (obj.Error != null)
                return obj;

            string hash;
            var rand = new Random();
            var randbytes = new byte[32];
            do
            {
                rand.NextBytes(randbytes);
                hash = randbytes.Aggregate("", (s, b) => s + b.ToString("X2"));
            } while (Tokens.ContainsKey(hash));

            Tokens.Add(hash, user);

            obj["token"] = hash;
            return obj;
        }

		public RestRequestArgs(RestVerbs verbs, IParameterCollection param, IRequest request, SecureRest.TokenData tokenData, IHttpContext context)
		{
			Verbs = verbs;
			Parameters = param;
			Request = request;
			TokenData = tokenData;
			Context = context;
		}

 object DestroyToken(RestVerbs verbs, IParameterCollection parameters)
 {
     var token = verbs["token"];
     try
     {
         Tokens.Remove(token);
     }
     catch (Exception)
     {
         return new Dictionary<string, string> { { "status", "400" }, { "error", "The specified token queued for destruction failed to be deleted." } };
     }
     return new Dictionary<string, string> { { "status", "200" }, { "response", "Requested token was successfully destroyed." } };
 }

        protected override object ExecuteCommand(RestCommand cmd, RestVerbs verbs, IParameterCollection parms)
        {
            if (cmd.RequiresToken)
            {
                var strtoken = parms["token"];
                if (strtoken == null)
                    return new Dictionary<string, string> { { "status", "401" }, { "error", "Not authorized. The specified API endpoint requires a token." } };

                object token;
                if (!Tokens.TryGetValue(strtoken, out token))
                    return new Dictionary<string, string> { { "status", "403" }, { "error", "Not authorized. The specified API endpoint requires a token, but the provided token was not valid." } };
            }
            return base.ExecuteCommand(cmd, verbs, parms);
        }

        private object GetInventory(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            List<TSPlayer> players = TShock.Utils.FindPlayer(verbs["user"]);
            if (players.Count > 1)
            {
                return new RestObject("400") {Response = "Found more than one match."};
            }
            else if (players.Count < 1)
            {
                return new RestObject("400") {Response = "Found no matches."};
            }

            string inventory = players[0].PlayerData.inventory.ToString();
            return new RestObject{{"inventory", inventory}};
        }

        object BanCreate(RestVerbs verbs, IParameterCollection parameters)
        {
            var returnBlock = new Dictionary<string, string>();
            var ip = parameters["ip"];
            var name = parameters["name"];
            var reason = parameters["reason"];

            if (ip == null && name == null)
            {
                returnBlock.Add("status", "400");
                returnBlock.Add("error", "Required parameters were missing from this API endpoint.");
                return returnBlock;
            }

            if (ip == null)
            {
                ip = "";
            }

            if (name == null)
            {
                name = "";
            }

            if (reason == null)
            {
                reason = "";
            }

            try
            {
                TShock.Bans.AddBan(ip, name, reason);
            }
            catch (Exception)
            {
                returnBlock.Add("status", "400");
                returnBlock.Add("error", "The specified ban was unable to be created.");
                return returnBlock;
            }
            returnBlock.Add("status", "200");
            returnBlock.Add("response", "Ban created successfully.");
            return returnBlock;
        }

 private object WorldRead(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     return new RestObject()
     {
         {"name", Main.worldName},
         {"size", Main.maxTilesX + "*" + Main.maxTilesY},
         {"time", Main.time},
         {"daytime", Main.dayTime},
         {"bloodmoon", Main.bloodMoon},
         {"invasionsize", Main.invasionSize}
     };
 }

        private object WorldChangeSaveSettings(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            bool autoSave;
            if (!bool.TryParse(verbs["bool"], out autoSave))
                return RestInvalidParam("state");
            TShock.Config.AutoSave = autoSave;

            return RestResponse("AutoSave has been set to " + autoSave);
        }

        private object WorldBloodmoon(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            bool bloodmoon;
            if (!bool.TryParse(verbs["bool"], out bloodmoon))
                return RestInvalidParam("bloodmoon");
            Main.bloodMoon = bloodmoon;

            return RestResponse("Blood Moon has been set to " + bloodmoon);
        }

 private object UserListV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     return new RestObject() { { "users", TShock.Users.GetUsers().Select(p => new Dictionary<string,object>(){
         {"name", p.Name},
         {"id", p.ID},
         {"group", p.Group},
     }) } };
 }

        private object UserDestroyV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            var ret = UserFind(parameters);
            if (ret is RestObject)
                return ret;

            try
            {
                TShock.Users.RemoveUser((User)ret);
            }
            catch (Exception e)
            {
                return RestError(e.Message);
            }

            return RestResponse("User deleted successfully");
        }

 private object UserActiveListV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     return new RestObject() { { "activeusers", string.Join("\t", TShock.Players.Where(p => null != p && null != p.UserAccountName && p.Active).Select(p => p.UserAccountName)) } };
 }

        private object PlayerReadV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            var ret = PlayerFind(parameters);
            if (ret is RestObject)
                return ret;

            TSPlayer player = (TSPlayer)ret;
            var activeItems = player.TPlayer.inventory.Where(p => p.active).ToList();
            return new RestObject()
            {
                {"nickname", player.Name},
                {"username", null == player.UserAccountName ? "" : player.UserAccountName},
                {"ip", player.IP},
                {"group", player.Group.Name},
                {"position", player.TileX + "," + player.TileY},
                {"inventory", string.Join(", ", activeItems.Select(p => (p.name + ":" + p.stack)))},
                {"buffs", string.Join(", ", player.TPlayer.buffType)}
            };
        }

 private object PlayerListV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     var playerList = new ArrayList();
     foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p))
     {
         var p = PlayerFilter(tsPlayer, parameters);
         if (null != p)
             playerList.Add(p);
     }
     return new RestObject() { { "players", playerList } };
 }

 private object PlayerList(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     var activeplayers = Main.player.Where(p => null != p && p.active).ToList();
     return new RestObject() { { "players", string.Join(", ", activeplayers.Select(p => p.name)) } };
 }

        private object ServerStatusV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            var ret = new RestObject()
            {
                {"name", TShock.Config.ServerName},
                {"port", TShock.Config.ServerPort},
                {"playercount", Main.player.Where(p => null != p && p.active).Count()},
                {"maxplayers", TShock.Config.MaxSlots},
                {"world", Main.worldName},
                {"uptime", (DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).ToString(@"d'.'hh':'mm':'ss")},
                {"serverpassword", !string.IsNullOrEmpty(TShock.Config.ServerPassword)}
            };

            if (GetBool(parameters["players"], false))
            {
                var players = new ArrayList();
                foreach (TSPlayer tsPlayer in TShock.Players.Where(p => null != p))
                {
                    var p = PlayerFilter(tsPlayer, parameters, ((tokenData.UserGroupName) != "" && TShock.Utils.GetGroup(tokenData.UserGroupName).HasPermission(RestPermissions.viewips)));
                    if (null != p)
                        players.Add(p);
                }
                ret.Add("players", players);
            }

            if (GetBool(parameters["rules"], false))
            {
                var rules = new Dictionary<string,object>();
                rules.Add("AutoSave", TShock.Config.AutoSave);
                rules.Add("DisableBuild", TShock.Config.DisableBuild);
                rules.Add("DisableClownBombs", TShock.Config.DisableClownBombs);
                rules.Add("DisableDungeonGuardian", TShock.Config.DisableDungeonGuardian);
                rules.Add("DisableInvisPvP", TShock.Config.DisableInvisPvP);
                rules.Add("DisableSnowBalls", TShock.Config.DisableSnowBalls);
                rules.Add("DisableTombstones", TShock.Config.DisableTombstones);
                rules.Add("EnableWhitelist", TShock.Config.EnableWhitelist);
                rules.Add("HardcoreOnly", TShock.Config.HardcoreOnly);
                rules.Add("PvPMode", TShock.Config.PvPMode);
                rules.Add("SpawnProtection", TShock.Config.SpawnProtection);
                rules.Add("SpawnProtectionRadius", TShock.Config.SpawnProtectionRadius);
                rules.Add("ServerSideInventory", TShock.Config.ServerSideCharacter);

                ret.Add("rules", rules);
            }
            return ret;
        }

 private object ServerTokenTest(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     return new RestObject()
     {
         {"response", "Token is valid and was passed through correctly."},
         {"associateduser", tokenData.Username}
     };
 }

 private object PlayerUnMute(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     return PlayerSetMute(parameters, false);
 }

        private object UserCreateV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
        {
            var username = parameters["user"];
            if (string.IsNullOrWhiteSpace(username))
                return RestMissingParam("user");

            var group = parameters["group"];
            if (string.IsNullOrWhiteSpace(group))
                group = TShock.Config.DefaultRegistrationGroupName;

            var password = parameters["password"];
            if (string.IsNullOrWhiteSpace(password))
                return RestMissingParam("password");

            // NOTE: ip can be blank
            User user = new User(username, password, "", group, "", "", "");
            try
            {
                TShock.Users.AddUser(user);
            }
            catch (Exception e)
            {
                return RestError(e.Message);
            }

            return RestResponse("User was successfully created");
        }

 private object ServerBroadcast(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
 {
     var msg = parameters["msg"];
     if (string.IsNullOrWhiteSpace(msg))
         return RestMissingParam("msg");
     TShock.Utils.Broadcast(msg);
     return RestResponse("The message was broadcasted successfully");
 }