private object GroupUpdate(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = GroupFind(parameters);
if (ret is RestObject)
{
return(ret);
}
Group group = (Group)ret;
var parent = (null == parameters["parent"]) ? group.ParentName : parameters["parent"];
var chatcolor = (null == parameters["chatcolor"]) ? string.Format("{0}.{1}.{2}", group.R, group.G, group.B) : parameters["chatcolor"];
var permissions = (null == parameters["permissions"]) ? group.Permissions : parameters["permissions"];
try
{
TShock.Groups.UpdateGroup(group.Name, parent, permissions, chatcolor);
}
catch (Exception e)
{
return(RestError(e.Message));
}
return(RestResponse("Group '" + group.Name + "' updated successfully"));
}
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 WorldMeteor(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
if (null == WorldGen.genRand)
{
WorldGen.genRand = new Random();
}
WorldGen.dropMeteor();
return(RestResponse("Meteor has been spawned"));
}
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 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 ServerRules(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
string rulesFilePath = Path.Combine(TShock.SavePath, "rules.txt");
if (!File.Exists(rulesFilePath))
{
return(this.RestError("The rules.txt was not found.", "500"));
}
return(new RestObject()
{
{ "rules", File.ReadAllLines(rulesFilePath) }
});
}
private object ServerOff(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
if (!GetBool(parameters["confirm"], false))
{
return(RestInvalidParam("confirm"));
}
// Inform players the server is shutting down
var reason = string.IsNullOrWhiteSpace(parameters["message"]) ? "Server is shutting down" : parameters["message"];
TShock.Utils.StopServer(!GetBool(parameters["nosave"], false), reason);
return(RestResponse("The server is shutting down"));
}
private object GroupList(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var groups = new ArrayList();
foreach (Group group in TShock.Groups)
{
groups.Add(new Dictionary <string, object> {
{ "name", group.Name }, { "parent", group.ParentName }, { "chatcolor", group.ChatColor }
});
}
return(new RestObject()
{
{ "groups", groups }
});
}
private object UserInfoV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = UserFind(parameters);
if (ret is RestObject)
{
return(ret);
}
User user = (User)ret;
return(new RestObject()
{
{ "group", user.Group }, { "id", user.ID.ToString() }, { "name", user.Name }
});
}
private object PlayerBanV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = PlayerFind(parameters);
if (ret is RestObject)
{
return(ret);
}
TSPlayer player = (TSPlayer)ret;
var reason = null == parameters["reason"] ? "Banned via web" : parameters["reason"];
TShock.Bans.AddBan(player.IP, player.Name, reason);
TShock.Utils.ForceKick(player, reason, false, true);
return(RestResponse("Player " + player.Name + " was banned"));
}
private object PlayerKill(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = PlayerFind(parameters);
if (ret is RestObject)
{
return(ret);
}
TSPlayer player = (TSPlayer)ret;
player.DamagePlayer(999999);
var from = string.IsNullOrWhiteSpace(parameters["from"]) ? "Server Admin" : parameters["from"];
player.SendMessage(string.Format("{0} just killed you!", from));
return(RestResponse("Player " + player.Name + " was killed"));
}
private object BanInfoV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = BanFind(parameters);
if (ret is RestObject)
{
return(ret);
}
Ban ban = (Ban)ret;
return(new RestObject()
{
{ "name", null == ban.Name ? "" : ban.Name },
{ "ip", null == ban.IP ? "" : ban.IP },
{ "reason", null == ban.Reason ? "" : ban.Reason },
});
}
private object GroupCreate(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var name = parameters["group"];
if (string.IsNullOrWhiteSpace(name))
{
return(RestMissingParam("group"));
}
try
{
TShock.Groups.AddGroup(name, parameters["parent"], parameters["permissions"], parameters["chatcolor"], true);
}
catch (Exception e)
{
return(RestError(e.Message));
}
return(RestResponse("Group '" + name + "' created successfully"));
}
private object BanCreate(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ip = parameters["ip"];
var name = parameters["name"];
if (string.IsNullOrWhiteSpace(ip) && string.IsNullOrWhiteSpace(name))
{
return(RestMissingParam("ip", "name"));
}
try
{
TShock.Bans.AddBan(ip, name, parameters["reason"], true, tokenData.Username);
}
catch (Exception e)
{
return(RestError(e.Message));
}
return(RestResponse("Ban created successfully"));
}
private object GroupInfo(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = GroupFind(parameters);
if (ret is RestObject)
{
return(ret);
}
Group group = (Group)ret;
return(new RestObject()
{
{ "name", group.Name },
{ "parent", group.ParentName },
{ "chatcolor", string.Format("{0},{1},{2}", group.R, group.G, group.B) },
{ "permissions", group.permissions },
{ "negatedpermissions", group.negatedpermissions },
{ "totalpermissions", group.TotalPermissions }
});
}
private object BanListV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var banList = new ArrayList();
foreach (var ban in TShock.Bans.GetBans())
{
banList.Add(
new Dictionary <string, string>
{
{ "name", null == ban.Name ? "" : ban.Name },
{ "ip", null == ban.IP ? "" : ban.IP },
{ "reason", null == ban.Reason ? "" : ban.Reason },
}
);
}
return(new RestObject()
{
{ "bans", banList }
});
}
private object PlayerKickV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = PlayerFind(parameters);
if (ret is RestObject)
{
return(ret);
}
TSPlayer player = (TSPlayer)ret;
TShock.Utils.ForceKick(player, null == parameters["reason"] ? "Kicked via web" : parameters["reason"], false, true);
return(RestResponse("Player " + player.Name + " was kicked"));
}
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 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 PlayerMute(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
return(PlayerSetMute(parameters, true));
}
private object WorldButcher(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
bool killFriendly;
if (!bool.TryParse(parameters["killfriendly"], out killFriendly))
{
return(RestInvalidParam("killfriendly"));
}
if (killFriendly)
{
killFriendly = !killFriendly;
}
int killcount = 0;
for (int i = 0; i < Main.npc.Length; i++)
{
if (Main.npc[i].active && Main.npc[i].type != 0 && !Main.npc[i].townNPC && (!Main.npc[i].friendly || killFriendly))
{
TSPlayer.Server.StrikeNPC(i, 99999, 90f, 1);
killcount++;
}
}
return(RestResponse(killcount + " NPCs have been killed"));
}
private object WorldSave(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
SaveManager.Instance.SaveWorld();
return(RestResponse("World saved"));
}
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 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 BanDestroyV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = BanFind(parameters);
if (ret is RestObject)
{
return(ret);
}
try
{
Ban ban = (Ban)ret;
switch (parameters["type"])
{
case "ip":
if (!TShock.Bans.RemoveBan(ban.IP, false, false, true))
{
return(RestResponse("Failed to delete ban (already deleted?)"));
}
break;
case "name":
if (!TShock.Bans.RemoveBan(ban.Name, true, GetBool(parameters["caseinsensitive"], true)))
{
return(RestResponse("Failed to delete ban (already deleted?)"));
}
break;
default:
return(RestError("Invalid Type: '" + parameters["type"] + "'"));
}
}
catch (Exception e)
{
return(RestError(e.Message));
}
return(RestResponse("Ban deleted successfully"));
}
private object GroupDestroy(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = GroupFind(parameters);
if (ret is RestObject)
{
return(ret);
}
Group group = (Group)ret;
try
{
TShock.Groups.DeleteGroup(group.Name, true);
}
catch (Exception e)
{
return(RestError(e.Message));
}
return(RestResponse("Group '" + group.Name + "' deleted successfully"));
}
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 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 UserUpdateV2(RestVerbs verbs, IParameterCollection parameters, SecureRest.TokenData tokenData)
{
var ret = UserFind(parameters);
if (ret is RestObject)
{
return(ret);
}
var password = parameters["password"];
var group = parameters["group"];
if (string.IsNullOrWhiteSpace(group) && string.IsNullOrWhiteSpace(password))
{
return(RestMissingParam("group", "password"));
}
User user = (User)ret;
var response = new RestObject();
if (!string.IsNullOrWhiteSpace(password))
{
try
{
TShock.Users.SetUserPassword(user, password);
response.Add("password-response", "Password updated successfully");
}
catch (Exception e)
{
return(RestError("Failed to update user password (" + e.Message + ")"));
}
}
if (!string.IsNullOrWhiteSpace(group))
{
try
{
TShock.Users.SetUserGroup(user, group);
response.Add("group-response", "Group updated successfully");
}
catch (Exception e)
{
return(RestError("Failed to update user group (" + e.Message + ")"));
}
}
return(response);
}
