the old core is dying :( http is better thou :)

BetterSecondbot/HttpService/Avatars.cs

@@ -76,37 +76,6 @@ namespace BetterSecondBot.HttpService
         }
 
 
-        [About("Makes the bot pay a avatar")]
+
-        [ReturnHints("Accepted")]
-        [ReturnHints("avatar lookup")]
-        [ReturnHints("Invaild amount")]
-        [ReturnHints("Transfer funds to avatars disabled")]
-        [Route(HttpVerbs.Get, "/PayAvatar/{avatar}/{amount}/{token}")]
-        public object PayAvatar(string avatar,string amount,string token)
-        {
-            if (tokens.Allow(token, "avatars", "payavatar", getClientIP()) == false)
-            {
-                return BasicReply("Token not accepted");
-            }
-            if (bot.GetAllowFunds == false)
-            {
-                return BasicReply("Transfer funds to avatars disabled");
-            }
-            ProcessAvatar(avatar);
-            if (avataruuid == UUID.Zero)
-            {
-                return BasicReply("avatar lookup");
-            }
-            if (int.TryParse(amount, out int amountvalue) == false)
-            {
-                return BasicReply("Invaild amount");
-            }
-            if(amountvalue < 1)
-            {
-                return BasicReply("Invaild amount");
-            }
-            bot.GetClient.Self.GiveAvatarMoney(avataruuid, amountvalue);
-            return BasicReply("Accepted");
-        }
     }
 }

BetterSecondbot/HttpService/Core.cs

@@ -47,21 +47,11 @@ namespace BetterSecondBot.HttpService
                     if(newtoken != null) return BasicReply(newtoken);
                 }
             }
-            return BasicReply("Authcode not accepted");
+            return Failure("Authcode not accepted");
         }
 
 
-        [About("Gets the friendslist <br/>Formated as follows<br/>friendreplyobject<br/><ul><li>name: String</li><li>id: String</li><li>online: bool</li></ul>")]
+
-        [ReturnHints("array UUID = friendreplyobject")]
-        [Route(HttpVerbs.Get, "/Friends/{token}")]
-        public object Friends(string token)
-        {
-            if (tokens.Allow(token, "core", "friends", getClientIP()) == true)
-            {
-                return BasicReply(bot.getJsonFriendlist());
-            }
-            return BasicReply("Token not accepted");
-        }
 
         [About("uses the AutoPilot to move to a location")]
         [ReturnHints("Error Unable to AutoPilot to location")]
@@ -79,9 +69,9 @@ namespace BetterSecondBot.HttpService
                 {
                     return BasicReply("Accepted");
                 }
-                return BasicReply("Error Unable to AutoPilot to location");
+                return Failure("Error Unable to AutoPilot to location");
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
         }
 
 
@@ -103,33 +93,11 @@ namespace BetterSecondBot.HttpService
                 {
                     return BasicReply("Accepted");
                 }
-                return BasicReply("Error Unable to Teleport to location");
+                return Failure("Error Unable to Teleport to location");
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
         }
 
-        [About("Fetchs the regions map tile")]
-        [ReturnHints("Unable to find region")]
-        [ReturnHints("Texture UUID")]
-        [ArgHints("regionname", "URLARG", "the name of the region we are fetching")]
-        [Route(HttpVerbs.Get, "/Regiontile/{regionname}/{token}")]
-        public object Regiontile(string regionname, string token)
-        {
-            if (tokens.Allow(token, "core", "regiontile", getClientIP()) == true)
-            {
-                if (bot.GetClient.Grid.GetGridRegion(regionname, GridLayerType.Objects, out GridRegion region))
-                {
-                    return BasicReply(region.MapImageID.ToString());
-                }
-                else
-                {
-                    return BasicReply("Unable to find region");
-                }
-            }
-            return BasicReply("Token not accepted");
-        }
-
-
 
         [About("Used to check HTTP connections")]
         [ReturnHints("world")]
@@ -144,79 +112,19 @@ namespace BetterSecondBot.HttpService
         [About("Removes the given token from the accepted token pool")]
         [ReturnHints("Failed to remove token")]
         [ReturnHints("ok")]
-        [Route(HttpVerbs.Get, "/Logout/{token}")]
+        [Route(HttpVerbs.Get, "/LogoutUI/{token}")]
-        public object Logout(string token)
+        public object LogoutUI(string token)
         {
-            if (tokens.Allow(token, "core", "logout", getClientIP()) == true)
+            if (tokens.Allow(token, "core", "LogoutUI", getClientIP()) == true)
             {
                 return tokens.Expire(token);
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
         }
 
 
 
-        [About("Fetchs the current bot")]
-        [ReturnHints("The build ID of the bot")]
-        [Route(HttpVerbs.Get, "/Version/{token}")]
-        public object Version(string token)
-        {
-            if (tokens.Allow(token, "core", "version", getClientIP()) == true)
-            {
-                return BasicReply(bot.MyVersion);
-            }
-            return BasicReply("Token not accepted");
-        }
 
-        [About("Fetchs the name of the bot")]
-        [ReturnHints("Firstname Lastname")]
-        [Route(HttpVerbs.Get, "/Name/{token}")]
-        public object Name(string token)
-        {
-            if (tokens.Allow(token, "core", "name", getClientIP()) == true)
-            {
-                return BasicReply(bot.GetClient.Self.FirstName + " " + bot.GetClient.Self.LastName);
-            }
-            return BasicReply("Token not accepted");
-        }
-
-        [About("Fetchs the current region name")]
-        [ReturnHints("Regionname")]
-        [ReturnHints("Error not in a sim")]
-        [Route(HttpVerbs.Get, "/Regionname/{token}")]
-        public object Regionname(string token)
-        {
-            if (tokens.Allow(token, "core", "regionname", getClientIP()) == true)
-            {
-                if(bot.GetClient.Network.CurrentSim != null)
-                {
-                    return BasicReply(bot.GetClient.Network.CurrentSim.Name);
-                }
-                return BasicReply("Error not in a sim");
-            }
-            return BasicReply("Token not accepted");
-        }
-
-        [About("Fetchs the current location of the bot")]
-        [ReturnHints("array of X,Y,Z values")]
-        [ReturnHints("Error not in a sim")]
-        [Route(HttpVerbs.Get, "/Location/{token}")]
-        public object Location(string token)
-        {
-            if (tokens.Allow(token, "core", "location", getClientIP()) == true)
-            {
-                if (bot.GetClient.Network.CurrentSim != null)
-                {
-                    Dictionary<string, int> pos = new Dictionary<string, int>();
-                    pos.Add("x", (int)Math.Round(bot.GetClient.Self.SimPosition.X));
-                    pos.Add("y", (int)Math.Round(bot.GetClient.Self.SimPosition.Y));
-                    pos.Add("z", (int)Math.Round(bot.GetClient.Self.SimPosition.Z));
-                    return BasicReply(JsonConvert.SerializeObject(pos));
-                }
-                return BasicReply("Error not in a sim");
-            }
-            return BasicReply("Token not accepted");
-        }
 
 
         [About("Makes a request to the core commands lib<br/>See LSL example on how to create a core command auth code")]
@@ -240,11 +148,11 @@ namespace BetterSecondBot.HttpService
                     {
                         return BasicReply("accepted");
                     }
-                    return BasicReply("Failed");
+                    return Failure("Failed");
                 }
-                return BasicReply("Auth not accepted");
+                return Failure("Auth not accepted");
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
         }
     }
 

BetterSecondbot/HttpService/Discord.cs

@@ -12,6 +12,8 @@ using System.Reflection;
 using Discord.WebSocket;
 using System.Threading.Tasks;
 using Discord;
+using BetterSecondBotShared.Static;
+using Discord.Rest;
 
 namespace BetterSecondBot.HttpService
 {
@@ -21,8 +23,7 @@ namespace BetterSecondBot.HttpService
 
         [About("Adds a discord server role to the selected member")]
         [ReturnHints("Discord client not ready")]
-        [ReturnHints("true")]
+        [ReturnHints("true|false")]
-        [ReturnHints("false")]
         [ArgHints("serverid","URLARG","the server id to apply this action to")]
         [ArgHints("roleid", "URLARG", "the role id we are giving")]
         [ArgHints("memberid", "URLARG", "who we are giving it to")]
@@ -31,36 +32,640 @@ namespace BetterSecondBot.HttpService
         {
             if (tokens.Allow(token, "discord", "Discord_AddRole", getClientIP()) == false)
             {
-                return BasicReply("Token not accepted");
+                return Failure("Token not accepted");
             }
             if (bot.discordReady() == false)
             {
-                return BasicReply("Discord client not ready");
+                return Failure("Discord client not ready");
             }
             return BasicReply(addRoleToMember(serverid, roleid, memberid).Result.ToString());
         }
 
         [About("Adds the selected user to the ban list - Disallows rejoining untill they are removed from the list")]
         [ReturnHints("Discord client not ready")]
-        [ReturnHints("true")]
+        [ReturnHints("Why empty")]
-        [ReturnHints("false")]
+        [ReturnHints("true|false")]
         [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
         [ArgHints("memberid", "URLARG", "who we are giving it to")]
         [ArgHints("why", "string", "why they are being banned")]
-        [Route(HttpVerbs.Get, "/Discord_BanMember/{serverid}/{memberid}/{token}")]
+        [Route(HttpVerbs.Post, "/Discord_BanMember/{serverid}/{memberid}/{token}")]
         public object Discord_BanMember(string serverid, string memberid, [FormField] string why, string token)
         {
             if (tokens.Allow(token, "discord", "Discord_BanMember", getClientIP()) == false)
             {
-                return BasicReply("Token not accepted");
+                return Failure("Token not accepted");
             }
             if (bot.discordReady() == false)
             {
-                return BasicReply("Discord client not ready");
+                return Failure("Discord client not ready");
+            }
+            if (helpers.notempty(why) == false)
+            {
+                return Failure("Why empty");
             }
             return BasicReply(BanMember(serverid, memberid, why).Result.ToString());
         }
 
+        [About("Clears messages on the server sent by the member in the last 13 days, 22hours 59mins")]
+        [ReturnHints("Discord client not ready")]
+        [ReturnHints("true|false")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("memberid", "URLARG", "who we are giving it to")]
+        [Route(HttpVerbs.Get, "/Discord_BulkClear_Messages/{serverid}/{memberid}/{token}")]
+        public object Discord_BulkClear_Messages(string serverid, string memberid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_BulkClear_Messages", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return ClearMessages(serverid, memberid).Result;
+        }
+
+        [About("Sends a message directly to the user [They must be in the server]\n This command requires the SERVER MEMBERS INTENT found in discord app dev")]
+        [ReturnHints("Discord client not ready")]
+        [ReturnHints("true|false")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("memberid", "URLARG", "who we are giving it to")]
+        [ArgHints("message", "Text", "what we are sending")]
+        [Route(HttpVerbs.Post, "/Discord_Dm_Member/{serverid}/{memberid}/{token}")]
+        public object Discord_Dm_Member(string serverid, string memberid, [FormField] string message, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_Dm_Member", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return BasicReply(MessageMember(serverid, memberid, message).Result.ToString());
+        }
+
+        [About("Returns a list of members in a server \n collection is userid: username \n if the user has set a nickname: userid: nickname|username \n" +
+            " This command requires Discord full client mode enabled and connected\n !!!! This command also requires: Privileged Gateway Intents / " +
+            "SERVER MEMBERS INTENT set to true on the discord bot api area !!!")]
+        [ReturnHints("Discord client not ready")]
+        [ReturnHints("mixed array of userid: nickname|username  or   userid:username")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [Route(HttpVerbs.Get, "/Discord_MembersList/{serverid}/{token}")]
+        public object Discord_MembersList(string serverid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_MembersList", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return ListMembers(serverid).Result;
+        }
+
+        [About("Sends a message to the selected channel - Optional TTS usage")]
+        [ReturnHints("Discord client not ready")]
+        [ReturnHints("true|false")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("channelid", "URLARG", "the channel id to apply this action to")]
+        [ArgHints("tts", "URLARG", "shoud tts be enabled true or false")]
+        [ArgHints("message", "Text", "what we are sending")]
+        [Route(HttpVerbs.Post, "/Discord_MembersList/{serverid}/{tts}/{token}")]
+        public object Discord_MessageChannel(string serverid, string channelid, string tts, [FormField] string message,  string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_MessageChannel", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            if (helpers.notempty(message) == false)
+            {
+                return Failure("message empty");
+            }
+            return BasicReply(MessageChannel(serverid, channelid, message, tts).Result.ToString());
+        }
+
+        [About("Sends a message to the selected channel - Optional TTS usage")]
+        [ReturnHints("mixed array of userid: nickname|username  or   userid:username")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("memberid", "URLARG", "who we are giving it to")]
+        [ArgHints("mode", "URLARG", "should we mute them \"true\" or unmute \"false\"")]
+        [Route(HttpVerbs.Get, "/Discord_MuteMember/{serverid}/{memberid}/{mode}/{token}")]
+        public object Discord_MuteMember(string serverid, string memberid, string mode, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_MuteMember", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return BasicReply(MuteMember(serverid, memberid, mode).Result.ToString());
+        }
+
+        [About("returns a collection of settings for the given role \n This command requires Discord full client mode enabled and connected")]
+        [ReturnHints("KeyPair of status: KeyPair[] item = value")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("memberid", "URLARG", "who we are giving it to")]
+        [ArgHints("mode", "URLARG", "should we mute them \"true\" or unmute \"false\"")]
+        [Route(HttpVerbs.Get, "/Discord_Role_GetSettings/{serverid}/{roleid}/{token}")]
+        public object Discord_Role_GetSettings(string serverid, string roleid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_Role_GetSettings", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return RoleSettings(serverid,roleid);
+        }
+
+        [About("Updates perm flags for the selected role \n example CSV format: Speak=True,SendMessages=False \n for a full list of perms see output of Discord_Role_GetSettings \n" +
+            " This command requires Discord full client mode enabled and connected")]
+        [ReturnHints("true|false")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("roleid", "URLARG", "who we are giving it to")]
+        [ArgHints("flagscsv", "Text", "what we are setting")]
+        [Route(HttpVerbs.Post, "/Discord_Role_UpdatePerms/{serverid}/{roleid}/{token}")]
+        public object Discord_Role_UpdatePerms(string serverid, string roleid, [FormField] string flagscsv, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_Role_UpdatePerms", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return BasicReply(UpdateRolePerms(serverid, roleid, flagscsv).Result.ToString());
+        }
+
+        [About("Updates perm flags for the selected role \n example CSV format: Speak=True,SendMessages=False \n for a full list of perms see output of Discord_Role_GetSettings \n" +
+    " This command requires Discord full client mode enabled and connected")]
+        [ReturnHints("KeyPair of statusmessage=roleid or 0")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [ArgHints("role", "URLARG", "the name of the role we are creating")]
+        [Route(HttpVerbs.Get, "/Discord_RoleCreate/{serverid}/{role}/{token}")]
+        public object Discord_RoleCreate(string serverid, string role, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_RoleCreate", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return CreateRole(serverid,role).Result;
+        }
+
+        [About("Returns a list of roles and their ids in collection \n This command requires Discord full client mode enabled and connected")]
+        [ReturnHints("KeyPair of status: KeyPair of roleid: rolename")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [Route(HttpVerbs.Get, "/Discord_RoleList/{serverid}/{token}")]
+        public object Discord_RoleList(string serverid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_RoleList", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return BasicReply(ListRoles(serverid).ToString());
+        }
+
+        [About("Remove a role from a server \n This command requires Discord full client mode enabled and connected")]
+        [ReturnHints("true|false")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [Route(HttpVerbs.Get, "/Discord_RoleRemove/{serverid}/{roleid}/{token}")]
+        public object Discord_RoleRemove(string serverid, string roleid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_RoleRemove", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return BasicReply(RemoveRole(serverid, roleid).Result.ToString());
+        }
+
+        [About("Returns a list of text channels in a server")]
+        [ReturnHints("array of channelid: name")]
+        [ReturnHints("Discord client not ready")]
+        [ArgHints("serverid", "URLARG", "the server id to apply this action to")]
+        [Route(HttpVerbs.Get, "/Discord_TextChannels_List/{serverid}/{roleid}/{token}")]
+        public object Discord_TextChannels_List(string serverid, string token)
+        {
+            if (tokens.Allow(token, "discord", "Discord_TextChannels_List", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.discordReady() == false)
+            {
+                return Failure("Discord client not ready");
+            }
+            return ListTextChannels(serverid);
+        }
+
+
+        #region discord helper functions
+
+        protected KeyValuePair<bool, Dictionary<string, string>> ListTextChannels(string givenserverid)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == true)
+            {
+                return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            Dictionary<string, string> textChannels = new Dictionary<string, string>();
+            foreach (SocketTextChannel channel in server.TextChannels)
+            {
+                textChannels.Add(channel.Id.ToString(), channel.Name);
+            }
+            return new KeyValuePair<bool, Dictionary<string, string>>(true, textChannels);
+        }
+
+        protected async Task<bool> RemoveRole(string givenserverid, string givenroleid)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return false;
+            }
+            if (ulong.TryParse(givenroleid, out ulong roleid) == false)
+            {
+                return false;
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            SocketRole role = server.GetRole(roleid);
+            await role.DeleteAsync().ConfigureAwait(true);
+            return true;
+        }
+
+        protected KeyValuePair<bool, Dictionary<string, string>> ListRoles(string givenserverid)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            Dictionary<string, string> rolesList = new Dictionary<string, string>();
+            foreach (SocketRole role in server.Roles)
+            {
+                rolesList.Add(role.Id.ToString(), role.Name);
+            }
+            return new KeyValuePair<bool, Dictionary<string, string>>(true, rolesList);
+        }
+
+        protected async Task<KeyValuePair<string, ulong>> CreateRole(string givenserverid, string givenrole)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == true)
+            {
+                return new KeyValuePair<string, ulong>("Unable to process server id", 0);
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            RestRole role = await server.CreateRoleAsync(givenrole, new GuildPermissions(), Color.DarkRed, false, null).ConfigureAwait(true);
+            return new KeyValuePair<string, ulong>("ok", role.Id);
+        }
+
+        protected async Task<bool> UpdateRolePerms(string givenserverid,string givenroleid,string givenflagscsv)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return false;
+            }
+            if (ulong.TryParse(givenroleid, out ulong roleid) == true)
+            {
+                return false;
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            SocketRole role = server.GetRole(roleid);
+            string[] bits = givenflagscsv.Split(',');
+            GuildPermissions NewPerms = role.Permissions;
+            foreach (String bit in bits)
+            {
+                string[] subbits = bit.Split('=');
+                if (subbits.Length == 2)
+                {
+                    if (bool.TryParse(subbits[1], out bool flagValue) == true)
+                    {
+                        NewPerms = UpdateFlag(NewPerms, subbits[0], flagValue);
+                    }
+                }
+            }
+            await role.ModifyAsync(Rp =>
+            {
+                Rp.Permissions = NewPerms;
+            }).ConfigureAwait(true);
+            return true;
+        }
+
+        protected GuildPermissions UpdateFlag(GuildPermissions NewPerms, string flag, bool flagValue)
+        {
+            switch (flag)
+            {
+                case "CreateInstantInvite":
+                    NewPerms = NewPerms.Modify(flagValue);
+                    break;
+                case "KickMembers":
+                    NewPerms = NewPerms.Modify(null, flagValue);
+                    break;
+                case "BanMembers":
+                    NewPerms = NewPerms.Modify(null, null, flagValue);
+                    break;
+                case "Administrator":
+                    NewPerms = NewPerms.Modify(null, null, null, flagValue);
+                    break;
+                case "ManageChannels":
+                    NewPerms = NewPerms.Modify(null, null, null, null, flagValue);
+                    break;
+                case "ManageGuild":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, flagValue);
+                    break;
+                case "AddReactions":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, flagValue);
+                    break;
+                case "ViewAuditLog":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "SendTTSMessages":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "AttachFiles":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ReadMessageHistory":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "MentionEveryone":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "UseExternalEmojis":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "Connect":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "Speak":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "MuteMembers":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "UseVAD":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "MoveMembers":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "EmbedLinks":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "PrioritySpeaker":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "Stream":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ChangeNickname":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ManageNicknames":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ManageRoles":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "DeafenMembers":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ManageMessages":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ViewChannel":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "SendMessages":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ManageWebhooks":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                case "ManageEmojis":
+                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
+                    break;
+                default:
+                    break;
+            }
+            return NewPerms;
+        }
+
+        protected KeyValuePair<bool, Dictionary<string, string>> RoleSettings(string givenserverid, string givenroleid)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
+            }
+            if (ulong.TryParse(givenroleid, out ulong roleid) == false)
+            {
+                return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            SocketRole role = server.GetRole(roleid);
+            Dictionary<string, string> settings = new Dictionary<string, string>
+            {
+                { "Config|Color", String.Join(",", new byte[3] { role.Color.R, role.Color.G, role.Color.B }) },
+                { "Config|Name", role.Name },
+                { "Info|AssignedCount", role.Members.ToString() },
+                { "Perm|AttachFiles", role.Permissions.AttachFiles.ToString() },
+                { "Perm|ReadMessageHistory", role.Permissions.ReadMessageHistory.ToString() },
+                { "Perm|MentionEveryone", role.Permissions.MentionEveryone.ToString() },
+                { "Perm|UseExternalEmojis", role.Permissions.UseExternalEmojis.ToString() },
+                { "Perm|Connect", role.Permissions.Connect.ToString() },
+                { "Perm|Speak", role.Permissions.Speak.ToString() },
+                { "Perm|MuteMembers", role.Permissions.MuteMembers.ToString() },
+                { "Perm|UseVAD", role.Permissions.UseVAD.ToString() },
+                { "Perm|MoveMembers", role.Permissions.MoveMembers.ToString() },
+                { "Perm|EmbedLinks", role.Permissions.EmbedLinks.ToString() },
+                { "Perm|PrioritySpeaker", role.Permissions.PrioritySpeaker.ToString() },
+                { "Perm|Stream", role.Permissions.Stream.ToString() },
+                { "Perm|ChangeNickname", role.Permissions.ChangeNickname.ToString() },
+                { "Perm|ManageNicknames", role.Permissions.ManageNicknames.ToString() },
+                { "Perm|ManageRoles", role.Permissions.ManageRoles.ToString() },
+                { "Perm|DeafenMembers", role.Permissions.DeafenMembers.ToString() },
+                { "Perm|ManageMessages", role.Permissions.ManageMessages.ToString() },
+                { "Perm|ViewChannel", role.Permissions.ViewChannel.ToString() },
+                { "Perm|SendMessages", role.Permissions.SendMessages.ToString() },
+                { "Perm|CreateInstantInvite", role.Permissions.CreateInstantInvite.ToString() },
+                { "Perm|BanMembers", role.Permissions.BanMembers.ToString() },
+                { "Perm|SendTTSMessages", role.Permissions.SendTTSMessages.ToString() },
+                { "Perm|Administrator", role.Permissions.Administrator.ToString() },
+                { "Perm|ManageChannels", role.Permissions.ManageChannels.ToString() },
+                { "Perm|KickMembers", role.Permissions.KickMembers.ToString() },
+                { "Perm|AddReactions", role.Permissions.AddReactions.ToString() },
+                { "Perm|ViewAuditLog", role.Permissions.ViewAuditLog.ToString() },
+                { "Perm|ManageWebhooks", role.Permissions.ManageWebhooks.ToString() },
+                { "Perm|ManageGuild", role.Permissions.ManageGuild.ToString() },
+                { "Perm|ManageEmojis", role.Permissions.ManageEmojis.ToString() }
+            };
+            return new KeyValuePair<bool, Dictionary<string, string>>(true, settings);
+        }
+
+        protected async Task<bool> MuteMember(string givenserverid, string givenmemberid, string mode)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == true)
+            {
+                return false;
+            }
+            if (ulong.TryParse(givenmemberid, out ulong memberid) == true)
+            {
+                return false;
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            SocketGuildUser user = server.GetUser(memberid);
+            bool.TryParse(mode, out bool status);
+            await user.ModifyAsync(pr =>
+            {
+                pr.Mute = status;
+            });
+            return true;
+        }
+
+        protected async Task<bool> MessageChannel(string givenserverid, string givenchannelid, string givenmessage, string tts)
+        {
+            if (bool.TryParse(tts, out bool useTTS) == false)
+            {
+                return false;
+            }
+            return await bot.SendMessageToDiscord(givenserverid, givenchannelid, givenmessage, useTTS);
+        }
+
+
+        protected async Task<KeyValuePair<bool, Dictionary<string, string>>> ListMembers(string givenserverid)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            IEnumerable<IGuildUser> users = await server.GetUsersAsync().FlattenAsync().ConfigureAwait(true);
+            Dictionary<string, string> membersList = new Dictionary<string, string>();
+
+            foreach (IGuildUser user in users)
+            {
+                if (user.Nickname != null)
+                {
+                    membersList.Add(user.Id.ToString(), user.Nickname + "|" + user.Username);
+                }
+                else
+                {
+                    membersList.Add(user.Id.ToString(), user.Username);
+                }
+            }
+            return new KeyValuePair<bool, Dictionary<string, string>>(true, membersList);            
+        }
+
+
+        protected async Task<bool> MessageMember(string givenserverid, string givenmemberid, string givenmessage)
+        {
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return false;
+            }
+            if (ulong.TryParse(givenmemberid, out ulong memberid) == false)
+            {
+                return false;
+            }
+            try
+            {
+                SocketGuild server = Discord.GetGuild(serverid);
+                IEnumerable<IGuildUser> users = await server.GetUsersAsync().FlattenAsync().ConfigureAwait(true);
+                bool sent = false;
+                foreach (IGuildUser user in users)
+                {
+                    if (user.Id == memberid)
+                    {
+                        sent = true;
+                        await user.SendMessageAsync(givenmessage);
+                        break;
+                    }
+                }
+                return sent;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        protected async Task<KeyValuePair<bool, int>> ClearMessages(string givenserverid, string givenmemberid)
+        {
+            int messagesDeleted = 0;
+            DiscordSocketClient Discord = bot.getDiscordClient();
+            if (ulong.TryParse(givenserverid, out ulong serverid) == false)
+            {
+                return new KeyValuePair<bool, int>(false, 0);
+            }
+            if (ulong.TryParse(givenmemberid, out ulong memberid) == false)
+            {
+                return new KeyValuePair<bool, int>(false, 0);
+            }
+            SocketGuild server = Discord.GetGuild(serverid);
+            SocketGuildUser user = server.GetUser(memberid);
+            TimeSpan somedays = new TimeSpan(13, 22, 59, 59, 0);
+            DateTimeOffset justundertwosweeks = DateTimeOffset.Now;
+            justundertwosweeks = justundertwosweeks.Subtract(somedays);
+            long unixtimelimit = justundertwosweeks.ToUnixTimeSeconds();
+            foreach (SocketTextChannel channel in server.TextChannels)
+            {
+                List<IMessage> DeleteMessages = new List<IMessage>();
+                IEnumerable<IMessage> messages = await channel.GetMessagesAsync(100).FlattenAsync();
+                foreach (IMessage message in messages)
+                {
+                    if (message.CreatedAt.ToUnixTimeSeconds() > unixtimelimit)
+                    {
+                        if (message.Author.Id == user.Id)
+                        {
+                            DeleteMessages.Add(message);
+                        }
+                    }
+                }
+                if (DeleteMessages.Count > 0)
+                {
+                    messagesDeleted += DeleteMessages.Count;
+                    await channel.DeleteMessagesAsync(DeleteMessages);
+                }
+            }
+            return new KeyValuePair<bool, int>(true, messagesDeleted);
+        }
+
+
 
         protected async Task<bool> BanMember(string givenserverid, string givenmemberid, string why)
         {
@@ -101,5 +706,8 @@ namespace BetterSecondBot.HttpService
             await user.AddRoleAsync(role); // ? Irole seems to accept SocketRole ?
             return true;
         }
+
+
+        #endregion
     }
 }

BetterSecondbot/HttpService/Estate.cs

@@ -5,6 +5,9 @@ using EmbedIO.Routing;
 using System;
 using Newtonsoft.Json;
 using OpenMetaverse;
+using System.Collections.Generic;
+using EmbedIO.WebApi;
+using BetterSecondBotShared.Static;
 
 namespace BetterSecondBot.HttpService
 {
@@ -18,20 +21,137 @@ namespace BetterSecondBot.HttpService
 
         }
 
+        [About("Sends the message to the current sim")]
+        [ReturnHints("Not an estate manager here")]
+        [ReturnHints("restarting")]
+        [ReturnHints("canceled")]
+        [ArgHints("delay", "URLARG", "How long to delay the restart for (30 to 240 secs) - defaults to 240 if out of bounds \n" +
+            "set to 0 if your canceling!")]
+        [ArgHints("mode", "URLARG", "true to start a restart, false to cancel")]
+        [Route(HttpVerbs.Get, "/SimRestart/{delay}/{mode}/{token}")]
+        public object SimRestart(string delay, string mode, string token)
+        {
+            if (tokens.Allow(token, "estate", "SimMessage", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetClient.Network.CurrentSim.IsEstateManager == false)
+            {
+                return Failure("Not an estate manager here");
+            }
+            bool.TryParse(mode, out bool modeflag);
+            if (modeflag == false)
+            {
+                bot.GetClient.Estate.CancelRestart();
+                return BasicReply("canceled");
+            }
+            int delay_restart = 60;
+            int.TryParse(delay, out delay_restart);
+            if((delay_restart < 30) || (delay_restart > 240))
+            {
+                delay_restart = 240;
+            }
+            bot.GetClient.Estate.RestartRegion(delay_restart);
+            return BasicReply("restarting");
+        }
+
+        [About("Sends the message to the current sim")]
+        [ReturnHints("Not an estate manager here")]
+        [ReturnHints("Message empty")]
+        [ReturnHints("ok")]
+        [ArgHints("message", "Text", "What the message is")]
+        [Route(HttpVerbs.Post, "/SimMessage/{token}")]
+        public object SimMessage([FormField] string message, string token)
+        {
+            if (tokens.Allow(token, "estate", "SimMessage", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (helpers.notempty(message) == false)
+            {
+                return Failure("Message empty");
+            }
+            if (bot.GetClient.Network.CurrentSim.IsEstateManager == false)
+            {
+                return Failure("Not an estate manager here");
+            }
+            bot.GetClient.Estate.SimulatorMessage(message);
+            return BasicReply("ok");
+        }
+
+        [About("Fetchs the regions map tile")]
+        [ReturnHints("Unable to find region")]
+        [ReturnHints("Texture UUID")]
+        [ArgHints("regionname", "URLARG", "the name of the region we are fetching")]
+        [Route(HttpVerbs.Get, "/GetSimTexture/{regionname}/{token}")]
+        public object GetSimTexture(string regionname, string token)
+        {
+            if (tokens.Allow(token, "estate", "GetSimTexture", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetClient.Grid.GetGridRegion(regionname, GridLayerType.Objects, out GridRegion region) == false)
+            {
+                return Failure("Unable to find region");
+            }
+            return BasicReply(region.MapImageID.ToString());
+        }
+
+        [About("Reclaims ownership of the current parcel")]
+        [ReturnHints("Not an estate manager here")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/EstateParcelReclaim/{token}")]
+        public Object EstateParcelReclaim(string token)
+        {
+            if (tokens.Allow(token, "estate", "EstateParcelReclaim", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetClient.Network.CurrentSim.IsEstateManager == false)
+            {
+                return Failure("Not an estate manager here");
+            }
+            int localid = bot.GetClient.Parcels.GetParcelLocalID(bot.GetClient.Network.CurrentSim, bot.GetClient.Self.SimPosition);
+            bot.GetClient.Parcels.Reclaim(bot.GetClient.Network.CurrentSim, localid);
+            return BasicReply("ok");
+        }
+
+        [About("Reclaims ownership of the current parcel")]
+        [ReturnHints("Not an estate manager here")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/GetSimGlobalPos/{regionname}/{token}")]
+        public Object GetSimGlobalPos(string regionname, string token)
+        {
+            if (tokens.Allow(token, "estate", "GetSimGlobalPos", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetClient.Grid.GetGridRegion(regionname, GridLayerType.Objects, out GridRegion region) == false)
+            {
+                return Failure("Unable to find region");
+            }
+            Dictionary<string, string> reply = new Dictionary<string, string>();
+            reply.Add("region", regionname);
+            reply.Add("X", region.X.ToString());
+            reply.Add("Y", region.Y.ToString());
+            return reply;
+        }
+
         [About("Requests the estate banlist")]
         [ReturnHints("")]
         [Route(HttpVerbs.Get, "/GetEstateBanList/{token}")]
         public Object GetEstateBanList(string token)
         {
-            if (tokens.Allow(token, "estate", "banlist", getClientIP()) == true)
+            if (tokens.Allow(token, "estate", "banlist", getClientIP()) == false)
             {
-                return BasicReply(JsonConvert.SerializeObject(bot._lastUpdatedSimBlacklist));
+                return Failure("Token not accepted");
             }
-            return BasicReply("Token not accepted");
+            return BasicReply(JsonConvert.SerializeObject(bot._lastUpdatedSimBlacklist));
         }
 
         [About("Attempts to add/remove the avatar to/from the Estate banlist")]
-        [ReturnHints("Request accepted")]
+        [ReturnHints("Unban request accepted")]
+        [ReturnHints("Ban request accepted")]
         [ReturnHints("Unable to find avatar UUID")]
         [ReturnHints("Unable to process global value please use true or false")]
         [ReturnHints("Not an estate manager on region {REGIONNAME}")]
@@ -42,33 +162,31 @@ namespace BetterSecondBot.HttpService
 
         public Object UpdateEstateBanlist(string avatar, string mode, string global, string token)
         {
-            if (tokens.Allow(token, "estate", "banlist-add", getClientIP()) == true)
+            if (tokens.Allow(token, "estate", "banlist-add", getClientIP()) == false)
             {
-                if(bot.GetClient.Network.CurrentSim.IsEstateManager == false)
+                return Failure("Token not accepted");
+            }
+            if (bot.GetClient.Network.CurrentSim.IsEstateManager == false)
             {
-                    return BasicReply("Not an estate manager on region "+ bot.GetClient.Network.CurrentSim.Name);
+                return Failure("Not an estate manager on region " + bot.GetClient.Network.CurrentSim.Name);
             }
             UUID avataruuid = UUID.Zero;
-                if(UUID.TryParse(avatar,out avataruuid) == false)
+            if (UUID.TryParse(avatar, out avataruuid) == false)
             {
-                    return BasicReply("Unable to find avatar UUID");
+                return Failure("Unable to find avatar UUID");
             }
             bool globalban = false;
-                if(bool.TryParse(global,out globalban) == false)
+            if (bool.TryParse(global, out globalban) == false)
             {
-                    return BasicReply("Unable to process global value please use true or false");
+                return Failure("Unable to process global value please use true or false");
             }
-                if(mode != "add")
+            if (mode != "add")
             {
                 bot.GetClient.Estate.UnbanUser(avataruuid, globalban);
+                return BasicReply("Unban request accepted");
             }
-                else
-                {
             bot.GetClient.Estate.BanUser(avataruuid, globalban);
-                }
+            return BasicReply("Ban request accepted");
-                return BasicReply("Request accepted");
-            }
-            return BasicReply("Token not accepted");
         }
     }
 }

BetterSecondbot/HttpService/Friends.cs

@@ -0,0 +1,114 @@
+using BetterSecondBot.bottypes;
+using BetterSecondBot.Static;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using Newtonsoft.Json;
+using System.Reflection;
+
+namespace BetterSecondBot.HttpService
+{
+    public class HTTP_Friends : WebApiControllerWithTokens
+    {
+        public HTTP_Friends(SecondBot mainbot, TokenStorage setuptokens) : base(mainbot, setuptokens) { }
+
+        [About("Gets the friendslist <br/>Formated as follows<br/>friendreplyobject<br/><ul><li>name: String</li><li>id: String</li><li>online: bool</li></ul>")]
+        [ReturnHints("array UUID = friendreplyobject")]
+        [Route(HttpVerbs.Get, "/Friendslist/{token}")]
+        public object Friendslist(string token)
+        {
+            if (tokens.Allow(token, "friends", "Friendslist", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            return BasicReply(bot.getJsonFriendlist());
+        }
+
+        [About("Updates the friend perms for avatar avatar to State \n if true grants (Online/Map/Modify) perms")]
+        [ArgHints("avatar", "URLARG", "A avatar uuid or Firstname Lastname")]
+        [ArgHints("state", "URLARG", "true: Grant perms, false: Remove perms")]
+        [ReturnHints("granted")]
+        [ReturnHints("removed")]
+        [ReturnHints("Not A friend")]
+        [ReturnHints("state invaild")]
+        [ReturnHints("avatar lookup")]
+        [Route(HttpVerbs.Get, "/FriendFullPerms/{avatar}/{state}/{token}")]
+        public object FriendFullPerms(string avatar, string state, string token)
+        {
+            if (tokens.Allow(token, "friends", "FriendFullPerms", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
+            }
+            bool status = false;
+            if (bool.TryParse(state, out status) == false)
+            {
+                return Failure("state invaild");
+            }
+            if (bot.GetClient.Friends.FriendList.ContainsKey(avataruuid) == false)
+            {
+                return Failure("Not A friend");
+            }
+            if (status == true)
+            {
+                bot.GetClient.Friends.GrantRights(avataruuid, FriendRights.CanSeeOnline | FriendRights.CanSeeOnMap | FriendRights.CanModifyObjects);
+                return BasicReply("granted");
+            }
+            bot.GetClient.Friends.GrantRights(avataruuid, FriendRights.None);
+            return BasicReply("removed");
+        }
+
+        [About("Updates the friend perms for avatar avatar to State \n if true grants (Online/Map/Modify) perms")]
+        [ReturnHints("Request sent")]
+        [ReturnHints("Removed")]
+        [ReturnHints("Already a friend")]
+        [ReturnHints("Not in friendslist")]
+        [ReturnHints("state invaild")]
+        [ReturnHints("avatar lookup")]
+        [ArgHints("avatar", "URLARG", "A avatar uuid or Firstname Lastname")]
+        [ArgHints("state", "URLARG", "true: Send invite, false: Remove from friendslist")]
+        [Route(HttpVerbs.Get, "/FriendRequest/{avatar}/{state}/{token}")]
+        public object FriendRequest(string avatar, string state, string token)
+        {
+            if (tokens.Allow(token, "friends", "FriendRequest", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
+            }
+            bool status = false;
+            if (bool.TryParse(state, out status) == false)
+            {
+                return Failure("state invaild");
+            }
+            if (bot.GetClient.Friends.FriendList.ContainsKey(avataruuid) == true)
+            {
+                if (status == false)
+                {
+                    bot.GetClient.Friends.TerminateFriendship(avataruuid);
+                    return BasicReply("Removed");
+                }
+            }
+            if (status == false)
+            {
+                return Failure("Not in friendslist");
+            }
+            bot.GetClient.Friends.OfferFriendship(avataruuid);
+            return BasicReply("Request sent");
+            
+        }
+    }
+
+
+}

BetterSecondbot/HttpService/Funds.cs

@@ -0,0 +1,112 @@
+using BetterSecondBot.bottypes;
+using BetterSecondBot.Static;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using Newtonsoft.Json;
+using BetterSecondBotShared.Static;
+
+namespace BetterSecondBot.HttpService
+{
+    public class Http_Funds : WebApiControllerWithTokens
+    {
+        public Http_Funds(SecondBot mainbot, TokenStorage setuptokens) : base(mainbot, setuptokens) { }
+
+        [About("Requests the current balance and requests the balance to update.")]
+        [ReturnHints("Current fund level")]
+        [ReturnHints("Funds commands are disabled")]
+        [Route(HttpVerbs.Get, "/Balance/{token}")]
+        public object Balance(string token)
+        {
+            if (tokens.Allow(token, "funds", "Balance", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetAllowFunds == false)
+            {
+                return Failure("Funds commands are disabled");
+            }
+            bot.GetClient.Self.RequestBalance();
+            return BasicReply(bot.GetClient.Self.Balance.ToString());
+        }
+
+        [About("Makes the bot pay a avatar")]
+        [ReturnHints("Accepted")]
+        [ReturnHints("avatar lookup")]
+        [ReturnHints("Invaild amount")]
+        [ReturnHints("Transfer funds to avatars disabled")]
+        [Route(HttpVerbs.Get, "/PayAvatar/{avatar}/{amount}/{token}")]
+        public object PayAvatar(string avatar, string amount, string token)
+        {
+            if (tokens.Allow(token, "funds", "PayAvatar", getClientIP()) == false)
+            {
+                return BasicReply("Token not accepted");
+            }
+            if (bot.GetAllowFunds == false)
+            {
+                return BasicReply("Transfer funds to avatars disabled");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return BasicReply("avatar lookup");
+            }
+            if (int.TryParse(amount, out int amountvalue) == false)
+            {
+                return BasicReply("Invaild amount");
+            }
+            if (amountvalue < 1)
+            {
+                return BasicReply("Invaild amount");
+            }
+            bot.GetClient.Self.GiveAvatarMoney(avataruuid, amountvalue);
+            return BasicReply("Accepted");
+        }
+
+        [About("Makes the bot pay a object")]
+        [ReturnHints("ok")]
+        [ReturnHints("Primname is empty")]
+        [ReturnHints("Current fund level")]
+        [ReturnHints("Invaild object UUID")]
+        [ReturnHints("Invaild amount")]
+        [ReturnHints("Amount out of range")]
+        [ReturnHints("Funds commands are disabled")]
+        [ArgHints("object", "URLARG", "UUID of the object to pay")]
+        [ArgHints("primname", "URLARG", "The name of the prim on the object to pay")]
+        [ArgHints("amount", "URLARG", "the amount to pay (from 1 to current balance)")]
+        [Route(HttpVerbs.Get, "/PayObject/{object}/{primname}/{amount}/{token}")]
+        public object PayObject(string objectuuid,string primname,string amount,string token)
+        {
+            if (tokens.Allow(token, "funds", "PayObject", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.GetAllowFunds == false)
+            {
+                return Failure("Funds commands are disabled");
+            }
+            if (UUID.TryParse(objectuuid, out UUID objectUUID) == false)
+            {
+                return Failure("Invaild object UUID");
+            }
+            if (int.TryParse(amount, out int amountvalue) == false)
+            {
+                return Failure("Invaild amount");
+            }
+            if((amountvalue < 0) || (amountvalue > bot.GetClient.Self.Balance))
+            {
+                return Failure("Amount out of range");
+            }
+            if(helpers.notempty(primname) == false)
+            {
+                return Failure("Primname is empty");
+            }
+            bot.GetClient.Self.GiveObjectMoney(objectUUID, amountvalue, primname);
+            return BasicReply("ok");
+        }
+    }
+}

BetterSecondbot/HttpService/Group.cs

@@ -22,59 +22,371 @@ namespace BetterSecondBot.HttpService
         [ReturnHints("Updating")]
         [ReturnHints("Unknown group")]
         [ReturnHints("Invaild group UUID")]
-        [ReturnHints("Unable to find avatar UUID")]
+        [ReturnHints("avatar lookup")]
         [ArgHints("group", "URLARG", "the UUID of the group")]
         [ArgHints("avatar", "URLARG", "the UUID of the avatar you wish to check with")]
-        [Route(HttpVerbs.Get, "/ismember/{group}/{avatar}/{token}")]
+        [Route(HttpVerbs.Get, "/IsGroupMember/{group}/{avatar}/{token}")]
-        public object ismember(string group,string avatar,string token)
+        public object IsGroupMember(string group, string avatar, string token)
         {
-            if (tokens.Allow(token, "groups", "ismember", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "IsGroupMember", getClientIP()) == true)
             {
-                if (UUID.TryParse(group, out UUID groupuuid) == true)
+                return Failure("Token not accepted");
-                {
-                    if (bot.MyGroups.ContainsKey(groupuuid) == true)
-                    {
-                        if (bot.NeedReloadGroupData(groupuuid) == false)
-                        {
-                            UUID avataruuid = UUID.Zero;
-                            if(UUID.TryParse(avatar,out avataruuid) == false)
-                            {
-                                string lookup = bot.FindAvatarName2Key(avatar);
-                                if (UUID.TryParse(lookup, out avataruuid) == false)
-                                {
-                                    return BasicReply("Unable to find avatar UUID");
             }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.NeedReloadGroupData(groupuuid) == true)
+            {
+                bot.GetClient.Groups.RequestGroupMembers(groupuuid);
+                return Failure("Updating");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
             }
             bool status = bot.FastCheckInGroup(groupuuid, avataruuid);
             return BasicReply(status.ToString());
         }
+
+        [About("Gets membership of a group")]
+        [ReturnHints("list of UUIDS of group members")]
+        [ReturnHints("Updating")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("avatar lookup")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [Route(HttpVerbs.Get, "/GetGroupMembers/{group}/{token}")]
+        public object GetGroupMembers(string group, string token)
+        {
+            if (tokens.Allow(token, "groups", "GetGroupMembers", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.NeedReloadGroupData(groupuuid) == true)
+            {
                 bot.GetClient.Groups.RequestGroupMembers(groupuuid);
-                        return BasicReply("Updating");
+                return Failure("Updating");
             }
-                    return BasicReply("Unknown group");
+            return bot.GetGroupMembers(groupuuid);
         }
-                return BasicReply("Invaild group UUID");
+
+        [About("Eject selected avatar from group")]
+        [ReturnHints("Requested")]
+        [ReturnHints("Updating")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Not in group")]
+        [ReturnHints("avatar lookup")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("avatar", "URLARG", "the UUID of the avatar you wish to check with")]
+        [Route(HttpVerbs.Get, "/GroupEject/{group}/{avatar}/{token}")]
+        public object GroupEject(string group, string avatar, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupEject", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
             }
-            return BasicReply("Token not accepted");
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.NeedReloadGroupData(groupuuid) == true)
+            {
+                bot.GetClient.Groups.RequestGroupMembers(groupuuid);
+                return Failure("Updating");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
+            }
+            bool status = bot.FastCheckInGroup(groupuuid, avataruuid);
+            if(status == false)
+            {
+                return BasicReply("Not in group");
+            }
+            bot.GetClient.Groups.EjectUser(groupuuid, avataruuid);
+            return BasicReply("Requested");
+        }
+
+        [About("Adds the avatar to the Group with the role \n if they are not in the group then it invites them aswell")]
+        [ReturnHints("Roles updated")]
+        [ReturnHints("Invite sent")]
+        [ReturnHints("Updating")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Invaild role UUID")]
+        [ReturnHints("Not in group")]
+        [ReturnHints("avatar lookup")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("avatar", "URLARG", "the UUID of the avatar you wish to check with")]
+        [Route(HttpVerbs.Get, "/GroupAddRole/{group}/{avatar}/{role}/{token}")]
+        public object GroupAddRole(string group, string avatar, string role, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupAddRole", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (UUID.TryParse(role, out UUID roleuuid) == false)
+            {
+                return Failure("Invaild role UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.NeedReloadGroupData(groupuuid) == true)
+            {
+                bot.GetClient.Groups.RequestGroupMembers(groupuuid);
+                return Failure("Updating");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
+            }
+            bool status = bot.FastCheckInGroup(groupuuid, avataruuid);
+            if (status == false)
+            {
+                bot.GetClient.Groups.Invite(groupuuid, new List<UUID>() { roleuuid }, avataruuid);
+                return BasicReply("Invite sent");
+            }
+            bot.GetClient.Groups.AddToRole(groupuuid, roleuuid, avataruuid);
+            return BasicReply("Roles updated");
+        }
+
+        [About("Eject selected avatar from group")]
+        [ReturnHints("Invite sent")]
+        [ReturnHints("Updating")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Already in group")]
+        [ReturnHints("avatar lookup")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("avatar", "URLARG", "the UUID of the avatar you wish to check with")]
+        [ArgHints("role", "URLARG", "the UUID of the role to invite them at the word \"everyone\"")]
+        [Route(HttpVerbs.Get, "/GroupInvite/{group}/{avatar}/{role}/{token}")]
+        public object GroupInvite(string group, string avatar, string role, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupInvite", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.NeedReloadGroupData(groupuuid) == true)
+            {
+                bot.GetClient.Groups.RequestGroupMembers(groupuuid);
+                return Failure("Updating");
+            }
+            ProcessAvatar(avatar);
+            if (avataruuid == UUID.Zero)
+            {
+                return Failure("avatar lookup");
+            }
+            bool status = bot.FastCheckInGroup(groupuuid, avataruuid);
+            if (status == true)
+            {
+                return Failure("Already in group");
+            }
+            if(role == "everyone")
+            {
+                role = UUID.Zero.ToString();
+            }
+            if(UUID.TryParse(role,out UUID roleuuid) == false)
+            {
+                return Failure("Unable to process role UUID");
+            }
+            bot.GetClient.Groups.Invite(groupuuid, new List<UUID>() { roleuuid }, avataruuid);
+            return BasicReply("Invite sent");
+        }
+
+        [About("Sends a group notice (No attachments please use GroupnoticeWithAttachment to attach items!)")]
+        [ReturnHints("Sending notice")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Title empty")]
+        [ReturnHints("Message empty")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("title", "Text", "The title of the group notice")]
+        [ArgHints("message", "Text", "The body of the group notice")]
+        [Route(HttpVerbs.Post, "/Groupnotice/{group}/{token}")]
+        public object Groupnotice(string group, [FormField] string title, [FormField] string message, string token)
+        {
+            if (tokens.Allow(token, "groups", "Groupnotice", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (helpers.notempty(title) == false)
+            {
+                return Failure("Title empty");
+            }
+            if (helpers.notempty(message) == false)
+            {
+                return Failure("Message empty");
+            }
+            GroupNotice NewNotice = new GroupNotice();
+            NewNotice.Subject = title;
+            NewNotice.Message = message;
+            NewNotice.OwnerID = bot.GetClient.Self.AgentID;
+            bot.GetClient.Groups.SendGroupNotice(groupuuid, NewNotice);
+            return BasicReply("Sending notice");
+        }
+
+        [About("Activates the selected title")]
+        [ReturnHints("Switching title")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Invaild role UUID")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("role", "URLARG", "tje UUID of the role")]
+        [Route(HttpVerbs.Get, "/GroupActiveTitle/{group}/{token}")]
+        public object GroupActiveTitle(string group, string role, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupActiveTitle", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (UUID.TryParse(role, out UUID roleuuid) == false)
+            {
+                return Failure("Invaild role UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            bot.GetClient.Groups.ActivateTitle(groupuuid, roleuuid);
+            return BasicReply("Switching title");
+        }
+
+        [About("Sets the selected group to the active group")]
+        [ReturnHints("Switching active group")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [Route(HttpVerbs.Get, "/GroupActiveGroup/{group}/{token}")]
+        public object GroupActiveGroup(string group, string role, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupActiveTitle", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            bot.GetClient.Groups.ActivateGroup(groupuuid);
+            return BasicReply("Switching active group");
+        }
+
+        [About("Sends a group notice with an attachment")]
+        [ReturnHints("Sending notice with attachment")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("Invaild group UUID")]
+        [ReturnHints("Invaild inventory UUID")]
+        [ReturnHints("Title empty")]
+        [ReturnHints("Message empty")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [ArgHints("attachment", "URLARG", "the UUID of inventory you wish to attach")]
+        [ArgHints("title", "Text", "The title of the group notice")]
+        [ArgHints("message", "Text", "The body of the group notice")]
+        [Route(HttpVerbs.Post, "/Groupnotice/{group}/{attachment}/{token}")]
+        public object GroupnoticeWithAttachment(string group, [FormField] string title, [FormField] string message, string attachment, string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupnoticeWithAttachment", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
+            {
+                return Failure("Invaild group UUID");
+            }
+            if (UUID.TryParse(attachment, out UUID inventoryuuid) == false)
+            {
+                return Failure("Invaild inventory UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (helpers.notempty(title) == false)
+            {
+                return Failure("Title empty");
+            }
+            if (helpers.notempty(message) == false)
+            {
+                return Failure("Message empty");
+            }
+            GroupNotice NewNotice = new GroupNotice();
+            NewNotice.Subject = title;
+            NewNotice.Message = message;
+            NewNotice.OwnerID = bot.GetClient.Self.AgentID;
+            NewNotice.AttachmentID = inventoryuuid;
+            bot.GetClient.Groups.SendGroupNotice(groupuuid, NewNotice);
+            return BasicReply("Sending notice with attachment");
         }
 
 
         [About("fetchs a list of all groups known to the bot")]
         [ReturnHints("array UUID=name")]
-        [Route(HttpVerbs.Get, "/listgroups/{token}")]
+        [Route(HttpVerbs.Get, "/GetGroupList/{token}")]
-        public object listgroups(string token)
+        public object GetGroupList(string token)
         {
-            if (tokens.Allow(token, "groups", "listgroups", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "GetGroupList", getClientIP()) == true)
             {
+                return Failure("Token not accepted");
+            }
             Dictionary<string, string> grouppackage = new Dictionary<string, string>();
-                foreach(KeyValuePair<UUID,Group> entry in bot.MyGroups)
+            foreach (KeyValuePair<UUID, Group> entry in bot.MyGroups)
             {
                 grouppackage.Add(entry.Value.ID.ToString(), entry.Value.Name);
             }
             return BasicReply(JsonConvert.SerializeObject(grouppackage));
         }
-            return BasicReply("Token not accepted");
-        }
 
         [About("Requests the roles for the selected group<br/>Replys with GroupRoleDetails object formated as follows <ul><li>UpdateUnderway (Bool)</li><li>RoleDataAge (Int) [default -1]</li><li>Roles (KeyPair array of UUID=Name)</li></ul><br/>")]
         [ReturnHints("GroupRoleDetails object")]
@@ -82,15 +394,21 @@ namespace BetterSecondBot.HttpService
         [ReturnHints("Invaild group UUID")]
         [ReturnHints("Updating")]
         [ArgHints("group", "URLARG", "the UUID of the group")]
-        [Route(HttpVerbs.Get, "/listgrouproles/{group}/{token}")]
+        [Route(HttpVerbs.Get, "/GetGroupRoles/{group}/{token}")]
-        public object listgrouproles(string group, string token)
+        public object GetGroupRoles(string group, string token)
         {
-            if (tokens.Allow(token, "groups", "listgrouproles", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "GetGroupRoles", getClientIP()) == true)
             {
-                if (UUID.TryParse(group, out UUID groupuuid) == true)
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(group, out UUID groupuuid) == false)
             {
-                    if (bot.MyGroups.ContainsKey(groupuuid) == true)
+                return Failure("Invaild group UUID");
+            }
+            if (bot.MyGroups.ContainsKey(groupuuid) == false)
             {
+                return Failure("Unknown group");
+            }
             GroupRoleDetails reply = new GroupRoleDetails();
             reply.UpdateUnderway = false;
             reply.RoleDataAge = -1;
@@ -107,68 +425,101 @@ namespace BetterSecondBot.HttpService
                 {
                     reply.UpdateUnderway = true;
                 }
-                            foreach(GroupRole gr in bot.MyGroupRolesStorage[groupuuid].Value)
+                foreach (GroupRole gr in bot.MyGroupRolesStorage[groupuuid].Value)
                 {
                     reply.Roles.Add(gr.ID.ToString(), gr.Name);
                 }
             }
-                        if(reply.UpdateUnderway == true)
+            if (reply.UpdateUnderway == true)
             {
                 bot.GetClient.Groups.RequestGroupRoles(groupuuid);
                 if (reply.Roles.Count == 0)
                 {
-                                return BasicReply("Updating");
+                    return Failure("Updating");
                 }
             }
             return BasicReply(JsonConvert.SerializeObject(reply));
         }
-                    return BasicReply("Group is not currently known");
-                }
-                return BasicReply("Invaild group UUID");
-            }
-            return BasicReply("Token not accepted");
-        }
 
         [About("fetchs a list of all groups with unread messages")]
         [ReturnHints("array UUID")]
-        [Route(HttpVerbs.Get, "/listgroupswithunread/{token}")]
+        [Route(HttpVerbs.Get, "/GroupchatListAllUnreadGroups/{token}")]
-        public object listgroupswithunread(string token)
+        public object GroupchatListAllUnreadGroups(string token)
         {
-            if (tokens.Allow(token, "groups", "listgroupswithunread", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "GroupchatListAllUnreadGroups", getClientIP()) == true)
             {
+                return Failure("Token not accepted");
+            }
             return BasicReply(JsonConvert.SerializeObject(bot.UnreadGroupchatGroups()));
         }
-            return BasicReply("Token not accepted");
+
+        [About("fetchs a list of all groups with unread messages")]
+        [ReturnHints("true")]
+        [ReturnHints("false")]
+        [ReturnHints("Unknown group")]
+        [ReturnHints("group value is invaild")]
+        [ArgHints("group", "URLARG", "the UUID of the group")]
+        [Route(HttpVerbs.Get, "/GroupchatGroupHasUnread/{group}/{token}")]
+        public object GroupchatGroupHasUnread(string group,string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupchatListAllUnreadGroups", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
             }
+            UUID groupUUID = UUID.Zero;
+            if(UUID.TryParse(group,out groupUUID) == false)
+            {
+                return Failure("group value is invaild");
+            }
+            if(bot.MyGroups.ContainsKey(groupUUID) == false)
+            {
+                return Failure("Unknown group");
+            }
+            return BasicReply(bot.GroupHasUnread(groupUUID).ToString());
+        }
+
 
         [About("checks if there are any groups with unread messages")]
         [ReturnHints("True|False")]
-        [Route(HttpVerbs.Get, "/haveunreadgroupchat/{token}")]
+        [Route(HttpVerbs.Get, "/GroupchatAnyUnread/{token}")]
         public object haveunreadgroupchat(string token)
         {
-            if (tokens.Allow(token, "groups", "haveunreadgroupchat", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "GroupchatAnyUnread", getClientIP()) == true)
             {
                 return BasicReply(bot.HasUnreadGroupchats().ToString());
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
+        }
+
+        [About("Clears all group chat buffers at once")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/GroupchatClearAll/{token}")]
+        public object GroupchatClearAll(string token)
+        {
+            if (tokens.Allow(token, "groups", "GroupchatClearAll", getClientIP()) == true)
+            {
+                bot.ClearAllGroupchat();
+                return BasicReply("ok");
+            }
+            return Failure("Token not accepted");
         }
 
         [About("fetchs the groupchat history")]
         [ReturnHints("Group UUID invaild")]
         [ReturnHints("Group Chat")]
         [ArgHints("group", "URLARG", "the UUID of the group")]
-        [Route(HttpVerbs.Get, "/getgroupchat/{group}/{token}")]
+        [Route(HttpVerbs.Get, "/GroupchatHistory/{group}/{token}")]
-        public object getgroupchat(string group, string token)
+        public object GroupchatHistory(string group, string token)
         {
-            if (tokens.Allow(token, "groups", "getgroupchat", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "GroupchatHistory", getClientIP()) == true)
             {
                 if (UUID.TryParse(group, out UUID groupUUID) == true)
                 {
                     return BasicReply(JsonConvert.SerializeObject(bot.GetGroupchat(groupUUID)));
                 }
-                return BasicReply("Group UUID invaild");
+                return Failure("Group UUID invaild");
             }
-            return BasicReply("Token not accepted");
+            return Failure("Token not accepted");
         }
 
         [About("sends a message to the groupchat")]
@@ -176,19 +527,31 @@ namespace BetterSecondBot.HttpService
         [ArgHints("message", "Text", "the message to send")]
         [ReturnHints("Group UUID invaild")]
         [ReturnHints("Processing")]
-        [Route(HttpVerbs.Post, "/sendgroupchat/{group}/{token}")]
+        [ReturnHints("Opening groupchat")]
-        public object sendgroupchat(string group, string token, [FormField] string message)
+        [ReturnHints("Sending")]
+        [Route(HttpVerbs.Post, "/Groupchat/{group}/{token}")]
+        public object Groupchat(string group, [FormField] string message, string token)
         {
-            if (tokens.Allow(token, "groups", "sendgroupchat", getClientIP()) == true)
+            if (tokens.Allow(token, "groups", "Groupchat", getClientIP()) == true)
             {
-                if (UUID.TryParse(group, out UUID groupUUID) == true)
+                return Failure("Token not accepted");
-                {
-                    bool status = bot.GetCommandsInterface.Call("Groupchat", group + "~#~" + message, UUID.Zero, "~#~");
-                    return BasicReply("Processing");
             }
-                return BasicReply("Group UUID invaild");
+            UUID groupUUID = UUID.Zero;
+            if (UUID.TryParse(group, out groupUUID) == false)
+            {
+                return Failure("group value is invaild");
             }
-            return BasicReply("Token not accepted");
+            if (bot.MyGroups.ContainsKey(groupUUID) == false)
+            {
+                return Failure("Unknown group");
+            }
+            if (bot.GetActiveGroupchatSessions.Contains(groupUUID) == false)
+            {
+                bot.GetClient.Self.RequestJoinGroupChat(groupUUID);
+                return Failure("Opening groupchat");
+            }
+            bot.GetClient.Self.InstantMessageGroup(groupUUID, message);
+            return BasicReply("Sending");
         }
     }
 

BetterSecondbot/HttpService/Home.cs

@@ -0,0 +1,33 @@
+using BetterSecondBot.bottypes;
+using BetterSecondBot.Static;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using Newtonsoft.Json;
+using BetterSecondBotShared.Static;
+
+namespace BetterSecondBot.HttpService
+{
+    public class Http_Home : WebApiControllerWithTokens
+    {
+        public Http_Home(SecondBot mainbot, TokenStorage setuptokens) : base(mainbot, setuptokens) { }
+
+        [About("Makes the bot teleport to its home region")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/GoHome/{token}")]
+        public object GoHome(string group, string token)
+        {
+            if (tokens.Allow(token, "groups", "GetGroupMembers", getClientIP()) == true)
+            {
+                return Failure("Token not accepted");
+            }
+            bot.GotoNextHomeRegion();
+            return BasicReply("ok");
+        }
+
+    }
+}

BetterSecondbot/HttpService/HttpAsService.cs

@@ -436,8 +436,15 @@ namespace BetterSecondBot.HttpService
 
         protected Object BasicReply(string input)
         {
-            return new { reply = input };
+            return new { reply = input, status=true };
         }
+
+        protected Object Failure(string input)
+        {
+            return new { reply = input, status = false };
+        }
+
+
         public WebApiControllerWithTokens(SecondBot mainbot, TokenStorage setuptokens)
         {
             bot = mainbot;

BetterSecondbot/HttpService/Info.cs

@@ -0,0 +1,116 @@
+using BetterSecondBot.bottypes;
+using BetterSecondBot.Static;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using Newtonsoft.Json;
+using BetterSecondBotShared.Static;
+
+namespace BetterSecondBot.HttpService
+{
+    public class Http_Info : WebApiControllerWithTokens
+    {
+        public Http_Info(SecondBot mainbot, TokenStorage setuptokens) : base(mainbot, setuptokens) { }
+
+        [About("Fetchs the current bot")]
+        [ReturnHints("The build ID of the bot")]
+        [Route(HttpVerbs.Get, "/Version/{token}")]
+        public object Version(string token)
+        {
+            if (tokens.Allow(token, "info", "Version", getClientIP()) == true)
+            {
+                return BasicReply(bot.MyVersion);
+            }
+            return Failure("Token not accepted");
+        }
+
+        [About("Fetchs the name of the bot")]
+        [ReturnHints("Firstname Lastname")]
+        [Route(HttpVerbs.Get, "/Name/{token}")]
+        public object Name(string token)
+        {
+            if (tokens.Allow(token, "info", "Name", getClientIP()) == true)
+            {
+                return BasicReply(bot.GetClient.Self.FirstName + " " + bot.GetClient.Self.LastName);
+            }
+            return Failure("Token not accepted");
+        }
+
+        [About("Fetchs the current parcels name")]
+        [ReturnHints("Parcelname")]
+        [ReturnHints("Error parcel not found")]
+        [ReturnHints("Error not in a sim")]
+        [Route(HttpVerbs.Get, "/ParcelName/{token}")]
+        public object ParcelName(string token)
+        {
+            if (tokens.Allow(token, "info", "ParcelName", getClientIP()) == true)
+            {
+                if (bot.GetClient.Network.CurrentSim != null)
+                {
+                    int localid = bot.GetClient.Parcels.GetParcelLocalID(bot.GetClient.Network.CurrentSim, bot.GetClient.Self.SimPosition);
+                    if (bot.GetClient.Network.CurrentSim.Parcels.ContainsKey(localid) == true)
+                    {
+                        return BasicReply(bot.GetClient.Network.CurrentSim.Parcels[localid].Name);
+                    }
+                    return Failure("Error parcel not found");
+                }
+                return Failure("Error not in a sim");
+            }
+            return Failure("Token not accepted");
+        }
+
+        [About("Requests the current unixtime at the bot")]
+        [ReturnHints("Unixtime")]
+        [Route(HttpVerbs.Get, "/UnixTimeNow/{token}")]
+        public object UnixTimeNow(string token)
+        {
+            if (tokens.Allow(token, "info", "UnixTimeNow", getClientIP()) == true)
+            {
+                return BasicReply(helpers.UnixTimeNow().ToString());
+            }
+            return Failure("Token not accepted");
+        }
+
+        [About("Fetchs the current region name")]
+        [ReturnHints("Regionname")]
+        [ReturnHints("Error not in a sim")]
+        [Route(HttpVerbs.Get, "/SimName/{token}")]
+        public object SimName(string token)
+        {
+            if (tokens.Allow(token, "info", "SimName", getClientIP()) == true)
+            {
+                if (bot.GetClient.Network.CurrentSim != null)
+                {
+                    return BasicReply(bot.GetClient.Network.CurrentSim.Name);
+                }
+                return Failure("Error not in a sim");
+            }
+            return Failure("Token not accepted");
+        }
+
+        [About("Fetchs the current location of the bot")]
+        [ReturnHints("array of X,Y,Z values")]
+        [ReturnHints("Error not in a sim")]
+        [Route(HttpVerbs.Get, "/GetPosition/{token}")]
+        public object GetPosition(string token)
+        {
+            if (tokens.Allow(token, "info", "GetPosition", getClientIP()) == true)
+            {
+                if (bot.GetClient.Network.CurrentSim != null)
+                {
+                    Dictionary<string, int> pos = new Dictionary<string, int>();
+                    pos.Add("x", (int)Math.Round(bot.GetClient.Self.SimPosition.X));
+                    pos.Add("y", (int)Math.Round(bot.GetClient.Self.SimPosition.Y));
+                    pos.Add("z", (int)Math.Round(bot.GetClient.Self.SimPosition.Z));
+                    return BasicReply(JsonConvert.SerializeObject(pos));
+                }
+                return Failure("Error not in a sim");
+            }
+            return Failure("Token not accepted");
+        }
+    }
+}

BetterSecondbot/HttpService/Self.cs

@@ -0,0 +1,131 @@
+using BetterSecondBot.bottypes;
+using BetterSecondBot.Static;
+using EmbedIO;
+using EmbedIO.Routing;
+using EmbedIO.WebApi;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using Newtonsoft.Json;
+using BetterSecondBotShared.Static;
+
+namespace BetterSecondBot.HttpService
+{
+    public class Http_Self : WebApiControllerWithTokens
+    {
+        public Http_Self(SecondBot mainbot, TokenStorage setuptokens) : base(mainbot, setuptokens) { }
+
+        [About("Makes the bot turn to face avatar and point at them (if found)")]
+        [ReturnHints("ok")]
+        [ReturnHints("Cant find UUID in sim")]
+        [Route(HttpVerbs.Get, "/PointAt/{avatar}/{token}")]
+        public object PointAt(string avatar, string token)
+        {
+            if (tokens.Allow(token, "self", "PointAt", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            ProcessAvatar(avatar);
+            if (bot.GetClient.Network.CurrentSim.AvatarPositions.ContainsKey(avataruuid) == false)
+            {
+                return Failure("Cant find UUID in sim");
+            }
+            bot.ResetAnimations();
+            bot.GetClient.Self.Stand();
+            bot.GetClient.Self.Movement.TurnToward(bot.GetClient.Network.CurrentSim.AvatarPositions[avataruuid]);
+            bot.GetClient.Self.Movement.SendUpdate();
+            bot.GetClient.Self.AnimationStart(Animations.POINT_YOU, true);
+            bot.GetClient.Self.PointAtEffect(bot.GetClient.Self.AgentID, avataruuid, new Vector3d(0, 0, 0), PointAtType.Select, UUID.Random());
+            bot.GetClient.Self.BeamEffect(bot.GetClient.Self.AgentID, avataruuid, new Vector3d(0, 0, 2), new Color4(255, 255, 255, 1), (float)3.0, UUID.Random());
+            return BasicReply("ok");
+        }
+
+        [About("Makes the bot sit on the ground or on a object if it can see it")]
+        [ReturnHints("ok")]
+        [ReturnHints("Invaild object UUID")]
+        [ArgHints("target", "URLARG", "ground or a object UUID")]
+        [Route(HttpVerbs.Get, "/Sit/{target}/{token}")]
+        public object Sit(string target, string token)
+        {
+            if (tokens.Allow(token, "self", "Sit", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if(target == "ground")
+            {
+                bot.GetClient.Self.SitOnGround();
+                return BasicReply("ok");
+            }
+            if(UUID.TryParse(target,out UUID objectuuid) == false)
+            {
+                return Failure("Invaild object UUID");
+            }
+            bot.GetClient.Self.RequestSit(objectuuid, Vector3.Zero);
+            return BasicReply("ok");
+        }
+
+        [About("Makes the bot stand up if sitting (also resets animations)")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/Stand/{token}")]
+        public object Stand(string target, string token)
+        {
+            if (tokens.Allow(token, "self", "Stand", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            bot.GetClient.Self.Stand();
+            bot.ResetAnimations();
+            return BasicReply("ok");
+        }
+
+        [About("Makes the bot sit on the ground or on a object if it can see it")]
+        [ReturnHints("true|false")]
+        [ReturnHints("Invaild object UUID")]
+        [ReturnHints("Unable to see object")]
+        [ArgHints("target", "URLARG", "object UUID")]
+        [Route(HttpVerbs.Get, "/ClickObject/{object}/{token}")]
+        public object ClickObject(string target, string token)
+        {
+            if (tokens.Allow(token, "self", "ClickObject", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (UUID.TryParse(target, out UUID objectuuid) == false)
+            {
+                return Failure("Invaild object UUID");
+            }
+            Dictionary<uint, Primitive> objectsentrys = bot.GetClient.Network.CurrentSim.ObjectsPrimitives.Copy();
+            bool found_object = false;
+            foreach (KeyValuePair<uint, Primitive> entry in objectsentrys)
+            {
+                if (entry.Value.ID == objectuuid)
+                {
+                    bot.GetClient.Objects.ClickObject(bot.GetClient.Network.CurrentSim, entry.Key);
+                    found_object = true;
+                    break;
+                }
+            }
+            return BasicReply(found_object.ToString());
+        }
+
+        [About("Makes the bot sit on the ground or on a object if it can see it")]
+        [ReturnHints("ok")]
+        [Route(HttpVerbs.Get, "/Logoff/{token}")]
+        public object Logoff(string token)
+        {
+            if (tokens.Allow(token, "self", "Logoff", getClientIP()) == false)
+            {
+                return Failure("Token not accepted");
+            }
+            if (bot.KillMe == false)
+            {
+                bot.GetClient.Self.Chat("Laters im out", 0, ChatType.Normal);
+                bot.KillMePlease();
+            }
+            return BasicReply("ok");
+        }
+
+
+    }
+}

Core/Commands/DiscordAPI/BulkClear_Messages.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_BulkClear_Messages : CoreCommand_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "Member id" }; } }
-        public override string Helpfile { get { return "Clears messages on the server sent by the member in the last 13 days, 22hours 59mins"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<bool, int> reply = ClearMessages(args).Result;
-                Dictionary<string, string> collection = new Dictionary<string, string>();
-                collection.Add("Deleted", reply.Value.ToString());
-                return bot.GetCommandsInterface.SmartCommandReply(reply.Key, args[0], "See status for state, see collection for total deleted", CommandName, collection);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<KeyValuePair<bool,int>> ClearMessages(string[] args)
-        {
-            int messagesDeleted = 0;
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong memberid) == true)
-                {
-                    SocketGuild server = Discord.GetGuild(serverid);
-                    SocketGuildUser user = server.GetUser(memberid);
-                    TimeSpan somedays = new TimeSpan(13, 22, 59, 59, 0);
-                    DateTimeOffset justundertwosweeks = DateTimeOffset.Now;
-                    justundertwosweeks = justundertwosweeks.Subtract(somedays);
-                    long unixtimelimit = justundertwosweeks.ToUnixTimeSeconds();
-                    foreach (SocketTextChannel channel in server.TextChannels)
-                    {
-                        List<IMessage> DeleteMessages = new List<IMessage>();
-                        IEnumerable<IMessage> messages = await channel.GetMessagesAsync(100).FlattenAsync();
-                        foreach (IMessage message in messages)
-                        {
-                            if (message.CreatedAt.ToUnixTimeSeconds() > unixtimelimit)
-                            {
-                                if (message.Author.Id == user.Id)
-                                {
-                                    DeleteMessages.Add(message);
-                                }
-                            }
-                        }
-                        if(DeleteMessages.Count() > 0)
-                        {
-                            messagesDeleted += DeleteMessages.Count();
-                            await channel.DeleteMessagesAsync(DeleteMessages);
-                        }
-                    }
-                    return new KeyValuePair<bool, int>(true, messagesDeleted);
-                }
-            }
-            return new KeyValuePair<bool, int>(false,0);
-        }
-    }
-}

Core/Commands/DiscordAPI/Dm_Member.cs

@@ -1,65 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_Dm_Member : CoreCommand_4arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number", "Text" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Server id", "Member id", "Message" }; } }
-        public override string Helpfile { get { return "Sends a message directly to the user [They must be in the server]\n This command requires the SERVER MEMBERS INTENT found in discord app dev"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                bool reply = MessageMember(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(reply, args[0], "see status for state", CommandName);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<bool> MessageMember(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong memberid) == true)
-                {
-                    try
-                    {
-                        SocketGuild server = Discord.GetGuild(serverid);
-                        IEnumerable<IGuildUser> users = await server.GetUsersAsync().FlattenAsync().ConfigureAwait(true);
-                        bool sent = false;
-                        foreach(IGuildUser user in users)
-                        {
-                            if(user.Id == memberid)
-                            {
-                                sent = true;
-                                await user.SendMessageAsync(args[3]);
-                                break;
-                            }
-                        }
-                        return sent;
-                    }
-                    catch
-                    {
-                        return false;
-                    }
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/DiscordAPI/MembersList.cs

@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_MembersList : CoreCommand_SmartReply_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id" }; } }
-        public override string Helpfile { get { return "Returns a list of members in a server \n collection is userid: username \n if the user has set a nickname: userid: nickname|username \n This command requires Discord full client mode enabled and connected\n !!!! This command also requires: Privileged Gateway Intents / SERVER MEMBERS INTENT set to true on the discord bot api area !!!"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<bool, Dictionary<string, string>> reply = ListMembers(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(reply.Key, args[0], "see status for state", CommandName, reply.Value);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<KeyValuePair<bool, Dictionary<string, string>>> ListMembers(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                SocketGuild server = Discord.GetGuild(serverid);
-                IEnumerable<IGuildUser> users = await server.GetUsersAsync().FlattenAsync().ConfigureAwait(true);
-                Dictionary<string, string> membersList = new Dictionary<string, string>();
-
-                foreach (IGuildUser user in users)
-                {
-                    if (user.Nickname != null)
-                    {
-                        membersList.Add(user.Id.ToString(), user.Nickname+"|"+user.Username);
-                    }
-                    else
-                    {
-                        membersList.Add(user.Id.ToString(), user.Username);
-                    }
-                }
-                return new KeyValuePair<bool, Dictionary<string, string>>(true, membersList);
-            }
-            return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
-        }
-    }
-}

Core/Commands/DiscordAPI/MessageChannel.cs

@@ -1,43 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_MessageChannel : CoreCommand_4arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number", "Message", "True|False" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "channel id", "Message to send", "Use TTS defaults to False" }; } }
-        public override string Helpfile { get { return "Sends a message to the selected channel - Optional TTS usage"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                bool reply = MessageChannel(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(reply, args[0], "see status for state", CommandName);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<bool> MessageChannel(string[] args)
-        {
-            bool useTTS = false;
-            if (args.Length == 5)
-            {
-                bool.TryParse(args[4], out useTTS);
-            }
-            return await bot.SendMessageToDiscord(args[1], args[2], args[3], useTTS);
-        }
-    }
-}

Core/Commands/DiscordAPI/MuteMember.cs

@@ -1,57 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_MuteMember : CoreCommand_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number", "True|False" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "Member id", "{Optional} Mute status (defaults to true) set this to False to unmute" }; } }
-        public override string Helpfile { get { return "Updates the Mute status of the member"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                bool reply = MuteMember(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(reply, args[0], "see status for state", CommandName);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<bool> MuteMember(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong memberid) == true)
-                {
-                    SocketGuild server = Discord.GetGuild(serverid);
-                    SocketGuildUser user = server.GetUser(memberid);
-                    bool status = true;
-                    if (args.Length == 4)
-                    {
-                        bool.TryParse(args[3], out status);
-                    }
-                    await user.ModifyAsync(pr =>
-                    {
-                        pr.Mute = status;
-                    });
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/DiscordAPI/RoleCreate.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_RoleCreate : CoreCommand_SmartReply_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart","Number","Text" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]","Discord server id","Role name" }; } }
-        public override string Helpfile { get { return "Creates a new role and returns its role ID via smart target\n This command requires Discord full client mode enabled and connected"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if(bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<string, ulong> reply = CreateRole(args).Result;
-                Dictionary<string, string> collection = new Dictionary<string, string>();
-                collection.Add("roleid", reply.Value.ToString());
-                return bot.GetCommandsInterface.SmartCommandReply(true, args[0], "ok", CommandName, collection);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<KeyValuePair<string,ulong>> CreateRole(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                SocketGuild server = Discord.GetGuild(serverid);
-                RestRole role = await server.CreateRoleAsync(args[2], new GuildPermissions(), Color.DarkRed, false, null).ConfigureAwait(true);
-                return new KeyValuePair<string, ulong>("ok", role.Id);
-            }
-            return new KeyValuePair<string, ulong>("Unable to process server id", 0);
-        }
-    }
-}

Core/Commands/DiscordAPI/RoleList.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_RoleList: CoreCommand_SmartReply_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id" }; } }
-        public override string Helpfile { get { return "Returns a list of roles and their ids in collection \n This command requires Discord full client mode enabled and connected"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<bool, Dictionary<string, string>> reply = ListRoles(args);
-                return bot.GetCommandsInterface.SmartCommandReply(reply.Key, args[0], "see status for state", CommandName, reply.Value);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected KeyValuePair<bool,Dictionary<string,string>> ListRoles(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                SocketGuild server = Discord.GetGuild(serverid);
-                Dictionary<string, string> rolesList = new Dictionary<string, string>();
-                foreach (SocketRole role in server.Roles)
-                {
-                    rolesList.Add(role.Id.ToString(), role.Name);
-                }
-                return new KeyValuePair<bool, Dictionary<string, string>>(true, rolesList);
-            }
-            return new KeyValuePair<bool, Dictionary<string, string>>(false,new Dictionary<string, string>());
-        }
-    }
-}

Core/Commands/DiscordAPI/RoleRemove.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_RoleRemove: CoreCommand_SmartReply_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "Role id" }; } }
-        public override string Helpfile { get { return "Remove a new role from a server \n This command requires Discord full client mode enabled and connected"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                bool status = RemoveRole(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(status, args[0], "see status for removal state", CommandName);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected async Task<bool> RemoveRole(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong roleid) == true)
-                {
-                    SocketGuild server = Discord.GetGuild(serverid);
-                    SocketRole role = server.GetRole(roleid);
-                    await role.DeleteAsync().ConfigureAwait(true);
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/DiscordAPI/Role_GetSettings.cs

@@ -1,84 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_Role_GetSettings : CoreCommand_SmartReply_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "Role id" }; } }
-        public override string Helpfile { get { return "returns a collection of settings for the given role \n This command requires Discord full client mode enabled and connected"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<bool, Dictionary<string, string>> reply = RoleSettings(args);
-                return bot.GetCommandsInterface.SmartCommandReply(reply.Key, args[0], "see status for state", CommandName,reply.Value);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected KeyValuePair<bool, Dictionary<string, string>> RoleSettings(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong roleid) == true)
-                {
-                    SocketGuild server = Discord.GetGuild(serverid);
-                    SocketRole role = server.GetRole(roleid);
-                    Dictionary<string, string> settings = new Dictionary<string, string>
-                    {
-                        { "Config|Color", String.Join(",", new byte[3] { role.Color.R, role.Color.G, role.Color.B }) },
-                        { "Config|Name", role.Name },
-                        { "Info|AssignedCount", role.Members.Count().ToString() },
-                        { "Perm|AttachFiles", role.Permissions.AttachFiles.ToString() },
-                        { "Perm|ReadMessageHistory", role.Permissions.ReadMessageHistory.ToString() },
-                        { "Perm|MentionEveryone", role.Permissions.MentionEveryone.ToString() },
-                        { "Perm|UseExternalEmojis", role.Permissions.UseExternalEmojis.ToString() },
-                        { "Perm|Connect", role.Permissions.Connect.ToString() },
-                        { "Perm|Speak", role.Permissions.Speak.ToString() },
-                        { "Perm|MuteMembers", role.Permissions.MuteMembers.ToString() },
-                        { "Perm|UseVAD", role.Permissions.UseVAD.ToString() },
-                        { "Perm|MoveMembers", role.Permissions.MoveMembers.ToString() },
-                        { "Perm|EmbedLinks", role.Permissions.EmbedLinks.ToString() },
-                        { "Perm|PrioritySpeaker", role.Permissions.PrioritySpeaker.ToString() },
-                        { "Perm|Stream", role.Permissions.Stream.ToString() },
-                        { "Perm|ChangeNickname", role.Permissions.ChangeNickname.ToString() },
-                        { "Perm|ManageNicknames", role.Permissions.ManageNicknames.ToString() },
-                        { "Perm|ManageRoles", role.Permissions.ManageRoles.ToString() },
-                        { "Perm|DeafenMembers", role.Permissions.DeafenMembers.ToString() },
-                        { "Perm|ManageMessages", role.Permissions.ManageMessages.ToString() },
-                        { "Perm|ViewChannel", role.Permissions.ViewChannel.ToString() },
-                        { "Perm|SendMessages", role.Permissions.SendMessages.ToString() },
-                        { "Perm|CreateInstantInvite", role.Permissions.CreateInstantInvite.ToString() },
-                        { "Perm|BanMembers", role.Permissions.BanMembers.ToString() },
-                        { "Perm|SendTTSMessages", role.Permissions.SendTTSMessages.ToString() },
-                        { "Perm|Administrator", role.Permissions.Administrator.ToString() },
-                        { "Perm|ManageChannels", role.Permissions.ManageChannels.ToString() },
-                        { "Perm|KickMembers", role.Permissions.KickMembers.ToString() },
-                        { "Perm|AddReactions", role.Permissions.AddReactions.ToString() },
-                        { "Perm|ViewAuditLog", role.Permissions.ViewAuditLog.ToString() },
-                        { "Perm|ManageWebhooks", role.Permissions.ManageWebhooks.ToString() },
-                        { "Perm|ManageGuild", role.Permissions.ManageGuild.ToString() },
-                        { "Perm|ManageEmojis", role.Permissions.ManageEmojis.ToString() }
-                    };
-                    return new KeyValuePair<bool, Dictionary<string, string>>(true, settings);
-                }
-            }
-            return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
-        }
-    }
-}

Core/Commands/DiscordAPI/Role_UpdatePerms.cs

@@ -1,165 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_Role_UpdatePerms : CoreCommand_4arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number", "Number","Text" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id", "Role id","CSV list of PermFlag=Bool" }; } }
-        public override string Helpfile { get { return "Updates perm flags for the selected role \n example CSV format: Speak=True,SendMessages=False \n for a full list of perms see output of DiscordRoleGetSettings \n This command requires Discord full client mode enabled and connected"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                bool status = UpdateRolePerms(args).Result;
-                return bot.GetCommandsInterface.SmartCommandReply(status, args[0], "see status for update state", CommandName);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected GuildPermissions UpdateFlag(GuildPermissions NewPerms,string flag, bool flagValue)
-        {
-            switch (flag)
-            {
-                case "CreateInstantInvite":
-                    NewPerms = NewPerms.Modify(flagValue);
-                    break;
-                case "KickMembers":
-                    NewPerms = NewPerms.Modify(null, flagValue);
-                    break;
-                case "BanMembers":
-                    NewPerms = NewPerms.Modify(null, null, flagValue);
-                    break;
-                case "Administrator":
-                    NewPerms = NewPerms.Modify(null, null, null, flagValue);
-                    break;
-                case "ManageChannels":
-                    NewPerms = NewPerms.Modify(null, null, null, null, flagValue);
-                    break;
-                case "ManageGuild":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, flagValue);
-                    break;
-                case "AddReactions":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, flagValue);
-                    break;
-                case "ViewAuditLog":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "SendTTSMessages":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "AttachFiles":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ReadMessageHistory":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "MentionEveryone":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "UseExternalEmojis":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "Connect":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "Speak":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "MuteMembers":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "UseVAD":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "MoveMembers":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "EmbedLinks":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "PrioritySpeaker":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "Stream":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ChangeNickname":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ManageNicknames":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ManageRoles":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "DeafenMembers":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ManageMessages":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ViewChannel":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "SendMessages":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ManageWebhooks":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                case "ManageEmojis":
-                    NewPerms = NewPerms.Modify(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, flagValue);
-                    break;
-                default:
-                    break;
-            }
-            return NewPerms;
-        }
-
-        protected async Task<bool> UpdateRolePerms(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                if (ulong.TryParse(args[2], out ulong roleid) == true)
-                {
-                    SocketGuild server = Discord.GetGuild(serverid);
-                    SocketRole role = server.GetRole(roleid);
-                    string[] bits = args[3].Split(',');
-                    GuildPermissions NewPerms = role.Permissions;
-                    foreach (String bit in bits)
-                    {
-                        string[] subbits = bit.Split('=');
-                        if(subbits.Length == 2)
-                        {
-                            if(bool.TryParse(subbits[1],out bool flagValue) == true)
-                            {
-                                NewPerms = UpdateFlag(NewPerms, subbits[0], flagValue);
-                            }
-                        }
-                    }
-                    await role.ModifyAsync(Rp =>
-                    {
-                        Rp.Permissions = NewPerms;
-                    }).ConfigureAwait(true);
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/DiscordAPI/TextChannels_List.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-using Newtonsoft.Json;
-using Discord.WebSocket;
-using Discord;
-using Discord.Rest;
-using System.Threading.Tasks;
-
-namespace BetterSecondBot.Commands.DiscordAPI
-{
-    class Discord_TextChannels_List : CoreCommand_SmartReply_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Smart", "Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Mixed [Channel|Avatar uuid|Avatar name|http url]", "Discord server id" }; } }
-        public override string Helpfile { get { return "Returns a list of text channels in a server \n collection is channelid: name"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.discordReady() == false)
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], bot.getDiscordWhyFailed(), CommandName);
-                }
-                KeyValuePair<bool, Dictionary<string, string>> reply = ListTextChannels(args);
-                return bot.GetCommandsInterface.SmartCommandReply(reply.Key, args[0], "see status for state", CommandName, reply.Value);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "incorrect args", CommandName);
-        }
-
-        protected KeyValuePair<bool, Dictionary<string, string>> ListTextChannels(string[] args)
-        {
-            DiscordSocketClient Discord = bot.getDiscordClient();
-            if (ulong.TryParse(args[1], out ulong serverid) == true)
-            {
-                SocketGuild server = Discord.GetGuild(serverid);
-                Dictionary<string, string> textChannels = new Dictionary<string, string>();
-                foreach(SocketTextChannel channel in server.TextChannels)
-                {
-                    textChannels.Add(channel.Id.ToString(), channel.Name);
-                }
-                return new KeyValuePair<bool, Dictionary<string, string>>(true, textChannels);
-            }
-            return new KeyValuePair<bool, Dictionary<string, string>>(false, new Dictionary<string, string>());
-        }
-    }
-}

Core/Commands/Estate/EstateParcelReclaim.cs

@@ -1,25 +0,0 @@
-namespace BetterSecondBot.Commands.Estate
-{
-    public class EstateParcelReclaim : CoreCommand
-    {
-        public override string Helpfile { get { return "Reclaims ownership of the current parcel"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetClient.Network.CurrentSim.IsEstateManager == true)
-                {
-                    int localid = bot.GetClient.Parcels.GetParcelLocalID(bot.GetClient.Network.CurrentSim, bot.GetClient.Self.SimPosition);
-                    bot.GetClient.Parcels.Reclaim(bot.GetClient.Network.CurrentSim, localid);
-                    return true;
-                }
-                else
-                {
-                    return Failed("Not an estate manager here");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Estate/GetSimGlobalPos.cs

@@ -1,27 +0,0 @@
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Estate
-{
-    public class GetSimGlobalPos : CoreCommand_SmartReply_2arg
-    {
-        public override string Helpfile { get { return "Fetchs a region and returns its global X,Y"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetClient.Grid.GetGridRegion(args[1], GridLayerType.Objects, out GridRegion region))
-                {
-                    collection.Add("X", region.X.ToString());
-                    collection.Add("Y", region.Y.ToString());
-                    return bot.GetCommandsInterface.SmartCommandReply(true, args[0], "ok", CommandName,collection);
-                }
-                else
-                {
-                    return Failed("Unable to find region");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Estate/GetSimTexture.cs

@@ -1,25 +0,0 @@
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Estate
-{
-    public class GetSimTexture : CoreCommand_SmartReply_2arg
-    {
-        public override string Helpfile { get { return "Fetchs a region and returns its tile texture UUID - Expect this to die at some point!"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetClient.Grid.GetGridRegion(args[1], GridLayerType.Objects, out GridRegion region))
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(true, args[0], region.MapImageID.ToString(),CommandName);
-                }
-                else
-                {
-                    return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "Unable to find region", CommandName);
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Estate/SimMessage.cs

@@ -1,26 +0,0 @@
-namespace BetterSecondBot.Commands.Estate
-{
-    public class SimMessage : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Text" }; } }
-        public override string[] ArgHints { get { return new[] { "Message to send" }; } }
-        public override string Helpfile { get { return "Sends the message [ARG 1] to the current sim"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetClient.Network.CurrentSim.IsEstateManager == true)
-                {
-                    bot.GetClient.Estate.SimulatorMessage(args[0]);
-                    return true;
-                }
-                else
-                {
-                    return Failed("Not an estate manager here");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Estate/SimRestart.cs

@@ -1,45 +0,0 @@
-namespace BetterSecondBot.Commands.Estate
-{
-    public class SimRestart : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "True|False","Number" }; } }
-        public override string[] ArgHints { get { return new[] { "Restart mode: True=Restart sim,False=Cancel restart","delay in secs to restart (Min 30 - max 240) defaults to 60 if not given" }; } }
-        public override string Helpfile { get { return "Sends the message [ARG 1] to the current sim"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetClient.Network.CurrentSim.IsEstateManager == true)
-                {
-                    
-                    if(bool.TryParse(args[0],out bool mode) == true)
-                    {
-                        if(mode == false)
-                        {
-                            bot.GetClient.Estate.CancelRestart();
-                        }
-                        else
-                        {
-                            int delay_restart = 60;
-                            if(args.Length == 2)
-                            {
-                                int.TryParse(args[1], out delay_restart);
-                            }
-                            bot.GetClient.Estate.RestartRegion(delay_restart);
-                        }
-                    }
-                    else
-                    {
-                        return Failed("True or False request for arg 1");
-                    }
-                }
-                else
-                {
-                    return Failed("Not an estate manager here");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Friends/FriendFullPerms.cs

@@ -1,42 +0,0 @@
-using System;
-using OpenMetaverse;
-namespace BetterSecondBot.Commands.Friends
-{
-    public class FriendFullPerms : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Avatar","True|False" }; } }
-        public override string[] ArgHints { get { return new[] { "Avatar UUID or Firstname Lastname","What status should it be" }; } }
-        public override string Helpfile { get { return "Updates the friend perms for avatar [Arg 1] to [Arg 2] (Online/Map/Modify)"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if(UUID.TryParse(args[0],out UUID avatar) == true)
-                {
-                    if(bool.TryParse(args[1],out bool status) == true)
-                    {
-                        if (bot.GetClient.Friends.FriendList.ContainsKey(avatar) == true)
-                        {
-                            if (status == true)
-                            {
-                                bot.GetClient.Friends.GrantRights(avatar, FriendRights.CanSeeOnline | FriendRights.CanSeeOnMap | FriendRights.CanModifyObjects);
-                                InfoBlob = "Friendship rights granted";
-                            }
-                            else
-                            {
-                                bot.GetClient.Friends.GrantRights(avatar, FriendRights.None);
-                                InfoBlob = "Friendship rights removed";
-                            }
-                            return true;
-                        }
-                        return Failed("Avatar not on friends list or friends list has not updated yet");
-                    }
-                    return Failed("Unable to process arg 2");
-                }
-                return Failed("Unable to process avatar on arg 1");
-            }
-            return false;
-        }
-    }
-
-}

Core/Commands/Friends/FriendRequest.cs

@@ -1,28 +0,0 @@
-using System;
-using OpenMetaverse;
-namespace BetterSecondBot.Commands.Friends
-{
-    public class FriendRequest : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Avatar" }; } }
-        public override string[] ArgHints { get { return new[] { "Avatar UUID or Firstname Lastname" }; } }
-        public override string Helpfile { get { return "sends a friend request to the target avatar"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID avatar) == true)
-                {
-                    if (bot.GetClient.Friends.FriendList.ContainsKey(avatar) == false)
-                    {
-                        bot.GetClient.Friends.OfferFriendship(avatar);
-                    }
-                    return true;
-                }
-                return Failed("Unable to process avatar on arg 1");
-            }
-            return false;
-        }
-    }
-
-}

Core/Commands/Friends/Friendslist.cs

@@ -1,18 +0,0 @@
-using System;
-using OpenMetaverse;
-namespace BetterSecondBot.Commands.Friends
-{
-    public class Friendslist : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Returns a copy of the friends list"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true, args[0], bot.getJsonFriendlist(), CommandName);
-            }
-            return false;
-        }
-    }
-
-}

Core/Commands/Group/GroupActiveGroup.cs

@@ -1,38 +0,0 @@
-using OpenMetaverse;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupActiveGroup : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Group"}; } }
-        public override string[] ArgHints { get { return new[] { "Group UUID or Name" }; } }
-        public override string Helpfile { get { return "Sets the selected group to the active group"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID group_uuid) != true)
-                {
-                    foreach (KeyValuePair<UUID, OpenMetaverse.Group> G in bot.MyGroups)
-                    {
-                        if (G.Value.Name == args[0])
-                        {
-                            group_uuid = G.Key;
-                            break;
-                        }
-                    }
-                }
-                if (group_uuid != UUID.Zero)
-                {
-                    bot.GetClient.Groups.ActivateGroup(group_uuid);
-                    return true;
-                }
-                return Failed("Unable to find group");
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupActiveTitle.cs

@@ -1,31 +0,0 @@
-using OpenMetaverse;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupActiveTitle : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "UUID"}; } }
-        public override string[] ArgHints { get { return new[] { "UUID of the group","UUID of the role" }; } }
-        public override string Helpfile { get { return "Activates the selected title"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if(UUID.TryParse(args[0],out UUID group_uuid) == true)
-                {
-                    if (UUID.TryParse(args[1], out UUID group_role) == true)
-                    {
-                        bot.GetClient.Groups.ActivateTitle(group_uuid, group_role);
-                        return true;
-                    }
-                    return Failed("Unable to process group Role on arg 1");
-                }
-                return Failed("Unable to process group UUID on arg 1");
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupAddRole.cs

@@ -1,108 +0,0 @@
-using System;
-using OpenMetaverse;
-using BetterSecondBotShared.logs;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupAddRole : CoreCommand_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Avatar", "UUID" }; } }
-        public override string[] ArgHints { get { return new[] { "GROUP", "Avatar [UUID or Firstname Lastname]", "Role" }; } }
-        public override string Helpfile { get { return "Adds the avatar [ARG 2] to the Group [ARG 1] with the role [ARG 3] if they are not in the group then it invites them"; } }
-
-        public override void Callback(string[] args, EventArgs e)
-        {
-            GroupMembersReplyEventArgs reply = (GroupMembersReplyEventArgs)e;
-            if (UUID.TryParse(args[0], out UUID target_group) == true)
-            {
-                if (reply.GroupID == target_group)
-                {
-                    if (UUID.TryParse(args[1], out UUID target_avatar) == true)
-                    {
-                        if (UUID.TryParse(args[2], out UUID target_role) == true)
-                        {
-                            if(reply.Members.ContainsKey(target_avatar) == true)
-                            {
-                                bot.GetClient.Groups.AddToRole(target_group, target_role, target_avatar);
-                                InfoBlob = "Role added to avatar: " + target_avatar.ToString() + "";
-                                base.Callback(args, e, true);
-                            }
-                            else
-                            {
-                                InfoBlob = "{GroupAddRole} Member not in group to get role, passing to invite";
-                                bot.GetCommandsInterface.Call("GroupInvite", String.Join("~#~", args), caller, "~#~");
-                                base.Callback(args, e, true);
-                            }
-
-                        }
-                        else
-                        {
-                            InfoBlob = "{ GroupAddRole} Unable to unpack role as part of the callback";
-                            base.Callback(args, e, false);
-                        }
-                    }
-                    else
-                    {
-                        InfoBlob = "{GroupAddRole} Unable to unpack avatar as part of the callback";
-                        base.Callback(args, e, false);
-                    }
-                }
-                else
-                {
-                    InfoBlob = "Callback sent for the wrong group as part of GroupAddRole!";
-                    base.Callback(args, e, false);
-                }
-            }
-            else
-            {
-                InfoBlob = "{GroupAddRole} Unable to unpack group as part of the callback";
-                base.Callback(args, e, false);
-            }
-        }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID target_group) == true)
-                {
-                    if (UUID.TryParse(args[1], out UUID _) == true)
-                    {
-                        if (UUID.TryParse(args[2], out UUID _) == true)
-                        {
-                            if (bot.MyGroups.ContainsKey(target_group) == true)
-                            {
-                                if (bot.CreateAwaitEventReply("groupmembersreply", this, args) == true)
-                                {
-                                    bot.GetClient.Groups.RequestGroupMembers(target_group);
-                                    InfoBlob = "Requesting group membership";
-                                    return true;
-                                }
-                                else
-                                {
-                                    return Failed("Unable to await reply");
-                                }
-                            }
-                            else
-                            {
-                                return Failed("I am not a member of that group");
-                            }
-                        }
-                        else
-                        {
-                            return Failed("Invaild role UUID");
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Invaild avatar UUID");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild group UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupEject.cs

@@ -1,45 +0,0 @@
-using System;
-using System.Collections.Generic;
-using OpenMetaverse;
-using BetterSecondBotShared.logs;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GroupEject : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Avatar" }; } }
-        public override string[] ArgHints { get { return new[] { "GROUP", "Avatar [UUID or Firstname Lastname]"}; } }
-        public override string Helpfile { get { return "Eject selected avatar from group"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID target_group) == true)
-                {
-                    if (UUID.TryParse(args[1], out UUID target_avatar) == true)
-                    {
-                        if (bot.MyGroups.ContainsKey(target_group) == true)
-                        {
-                            bot.GetClient.Groups.EjectUser(target_group, target_avatar);
-                            return true;
-                        }
-                        else
-                        {
-                            return Failed("I am not a member of that group");
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Invaild avatar UUID");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild group UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupInvite.cs

@@ -1,65 +0,0 @@
-using System;
-using System.Collections.Generic;
-using OpenMetaverse;
-using BetterSecondBotShared.logs;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GroupInvite : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Avatar", "UUID" }; } }
-        public override string[] ArgHints { get { return new[] { "GROUP", "Avatar [UUID or Firstname Lastname]", "Role" }; } }
-        public override string Helpfile { get { return "Invites the avatar [ARG 2] to the Group [ARG 1] {optional with the Role [ARG 3]} otherwise to role Everyone"; } }
-
-        protected void ForRealGroupInvite(string[] args,UUID group,UUID avatar)
-        {
-            UUID target_role = UUID.Zero;
-            if (args.Length == 3)
-            {
-                if(UUID.TryParse(args[2], out target_role) == false)
-                {
-                    LogFormater.Warn("GroupInvite: Role uuid not vaild using everyone");
-                }
-            }            
-            bot.GetClient.Groups.Invite(group, new List<UUID>() { target_role }, avatar);
-        }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID target_group) == true)
-                {
-                    if (UUID.TryParse(args[1], out UUID target_avatar) == true)
-                    {
-                        if (bot.MyGroups.ContainsKey(target_group) == true)
-                        {
-                            if (bot.GetAllowGroupInvite(target_avatar, target_group) == true)
-                            {
-                                bot.GroupInviteLockoutArm(target_avatar,target_group); // enable 120 sec cooldown
-                                ForRealGroupInvite(args, target_group, target_avatar);
-                                return true;
-                            }
-                            else
-                            {
-                                return Failed("Group invite to this avatar is on 120sec cooldown");
-                            }
-                        }
-                        else
-                        {
-                            return Failed("I am not a member of that group");
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Invaild avatar UUID");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild group UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupInviteNoLimiter.cs

@@ -1,58 +0,0 @@
-using BetterSecondBotShared.logs;
-using OpenMetaverse;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupInviteNoLimiter: CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Avatar", "UUID" }; } }
-        public override string[] ArgHints { get { return new[] { "GROUP", "Avatar [UUID or Firstname Lastname]", "Role" }; } }
-        public override string Helpfile { get { return "see GroupInvite, note: This command bypasses the limiter use at your own risk!"; } }
-
-        protected void ForRealGroupInvite(string[] args, UUID group, UUID avatar)
-        {
-            UUID target_role = UUID.Zero;
-            if (args.Length == 3)
-            {
-                if (UUID.TryParse(args[2], out target_role) == false)
-                {
-                    LogFormater.Warn("GroupInviteNoLimiter: Role uuid not vaild using everyone");
-                }
-            }
-            bot.GetClient.Groups.Invite(group, new List<UUID>() { target_role }, avatar);
-        }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID target_group) == true)
-                {
-                    if (UUID.TryParse(args[1], out UUID target_avatar) == true)
-                    {
-                        if (bot.MyGroups.ContainsKey(target_group) == true)
-                        {
-                            ForRealGroupInvite(args, target_group, target_avatar);
-                            return true;
-                        }
-                        else
-                        {
-                            return Failed("I am not a member of that group");
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Invaild avatar UUID");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild group UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/GroupNotice.cs

@@ -1,53 +0,0 @@
-using BetterSecondBotShared.Static;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class Groupnotice : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "TEXT","TEXT","TEXT" }; } }
-        public override string[] ArgHints { get { return new[] { "Group", "Message/Title", "Message","Inventory UUID" }; } }
-        public override string Helpfile { get { return "Sends a group notice to [ARG 1] with the message [ARG 2]<hr/>if given 3 Args: Sends a group notice to [ARG 1] with the title [ARG 2] and the message [ARG 3]<br/>if [ARG 4] is given then it also sends the notice with an attachment"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID targetgroup) == true)
-                {
-                    if (bot.MyGroups.ContainsKey(targetgroup) == true)
-                    {
-                        string Noticetitle = "GroupNotice@"+ helpers.UnixTimeNow().ToString()+"";
-                        string Noticemessage = args[1];
-                        if (args.Length >= 3)
-                        {
-                            Noticetitle = args[1];
-                            Noticemessage = args[2];
-                        }
-                        GroupNotice NewNotice = new GroupNotice();
-                        NewNotice.Subject = Noticetitle;
-                        NewNotice.Message = Noticemessage;
-                        NewNotice.OwnerID = bot.GetClient.Self.AgentID;
-                        if (args.Length == 4)
-                        {
-                            if (UUID.TryParse(args[3], out UUID result) == true)
-                            {
-                                NewNotice.AttachmentID = result;
-                            }
-                        }
-                        bot.GetClient.Groups.SendGroupNotice(targetgroup, NewNotice);
-                        return true;
-                    }
-                    else
-                    {
-                        return Failed("Unkown group");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/IsGroupMember.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Newtonsoft.Json;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class IsGroupMember : CoreCommand_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Mixed", "Avatar" }; } }
-        public override string[] ArgHints { get { return new[] { "Group", "Smart reply [Channel|IM uuid|http url]", "Avatar [UUID or Firstname Lastname]" }; } }
-        public override string Helpfile { get { return "Returns if the selected user is in the group or not"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID targetgroup) == true)
-                {
-                    if (UUID.TryParse(args[2], out UUID testavatar) == true)
-                    {
-                        if (bot.FastCheckInGroup(targetgroup, testavatar) == true)
-                        {
-                            Dictionary<string, string> reply = new Dictionary<string, string>
-                            {
-                                { "group", args[0] },
-                                { "avatar", args[2] },
-                                { "ingroup", "1" }
-                            };
-                            return bot.GetCommandsInterface.SmartCommandReply(true, args[1], JsonConvert.SerializeObject(reply), CommandName);
-                        }
-                        else
-                        {
-                            if (bot.MyGroups.ContainsKey(targetgroup) == true)
-                            {
-                                if (bot.CreateAwaitEventReply("groupmembersreply", this, args) == true)
-                                {
-                                    bot.GetClient.Groups.RequestGroupMembers(targetgroup);
-                                    InfoBlob = "Requesting group membership";
-                                    return true;
-                                }
-                                else
-                                {
-                                    return Failed("Unable to await reply");
-                                }
-
-                            }
-                            else
-                            {
-                                return Failed("Unknown group");
-                            }
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Unable to find avatar");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild UUID");
-                }
-            }
-            return false;
-        }
-
-        public override void Callback(string[] args, EventArgs e)
-        {
-            if (UUID.TryParse(args[2], out UUID testavatar) == true)
-            {
-                GroupMembersReplyEventArgs members_reply = (GroupMembersReplyEventArgs)e;
-                string return_status = "0";
-                foreach (KeyValuePair<UUID, GroupMember> data in members_reply.Members)
-                {
-                    if (data.Value.ID == testavatar)
-                    {
-                        return_status = "1";
-                        break;
-                    }
-                }
-                Dictionary<string, string> reply = new Dictionary<string, string>
-                {
-                    { "group", args[0] },
-                    { "avatar", args[2] },
-                    { "ingroup", return_status }
-                };
-                bot.GetCommandsInterface.SmartCommandReply(true, args[1], JsonConvert.SerializeObject(reply), CommandName);
-            }
-            base.Callback(args, e);
-        }
-    }
-}

Core/Commands/Group/getGroupList.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GetGroupList : CoreGroupCommand_SmartReply_auto
-    {
-        public override string Helpfile { get { return "Gets a list of groups Json encoded"; } }
-        protected override string RunFunction()
-        {
-            foreach (KeyValuePair<UUID, OpenMetaverse.Group> groupdata in bot.MyGroups)
-            {
-                collection.Add(groupdata.Value.Name, groupdata.Key.ToString());
-            }
-            return "grouplist=loaded";
-        }
-    }
-}

Core/Commands/Group/getGroupMembers.cs

@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GetGroupMembers : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID", "Mixed" }; } }
-        public override string[] ArgHints { get { return new[] { "Group", "Smart reply [Channel|IM uuid|http url]" }; } }
-        public override string Helpfile { get { return "Gets membership of a group plus online status "; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID targetgroup) == true)
-                {
-                    if (bot.MyGroups.ContainsKey(targetgroup) == true)
-                    {
-                        if (bot.CreateAwaitEventReply("groupmembersreply", this, args) == true)
-                        {
-                            bot.GetClient.Groups.RequestGroupMembers(targetgroup);
-                            InfoBlob = "Requesting group membership";
-                            return true;
-                        }
-                        else
-                        {
-                            return Failed("Unable to await reply");
-                        }
-
-                    }
-                    else
-                    {
-                        return Failed("Unknown group");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild UUID");
-                }
-            }
-            return false;
-        }
-
-        public override void Callback(string[] args, EventArgs e)
-        {
-            GroupMembersReplyEventArgs members_reply = (GroupMembersReplyEventArgs)e;
-            Dictionary<string, string> collection = new Dictionary<string, string>();
-            foreach (KeyValuePair<UUID, GroupMember> data in members_reply.Members)
-            {
-                collection.Add(data.Key.ToString(), data.Value.OnlineStatus);
-            }
-            bot.GetCommandsInterface.SmartCommandReply(true, args[1], "group=" + args[0], CommandName, collection);
-            base.Callback(args, e);
-        }
-    }
-}

Core/Commands/Group/getGroupRoles.cs

@@ -1,50 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GetGroupRoles : CoreGroupCommand_SmartReply_Group
-    {
-        public override string Helpfile { get { return "Gets a list of group roles Json encoded "; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[1], out UUID group) == true)
-                {
-                    if (bot.CreateAwaitEventReply("grouproles", this, args) == true)
-                    {
-                        InfoBlob = "Requesting now";
-                        bot.GetClient.Groups.RequestGroupRoles(group);
-                        return true;
-                    }
-                    else
-                    {
-                        return Failed("Unable to await reply");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild group UUID");
-                }
-            }
-            return false;
-        }
-
-        public override void Callback(string[] args, EventArgs e)
-        {
-            GroupRolesDataReplyEventArgs rolesData = (GroupRolesDataReplyEventArgs)e;
-            foreach(KeyValuePair<UUID,GroupRole> data in rolesData.Roles)
-            {
-                if (data.Key != UUID.Zero)
-                {
-                    collection.Add(data.Value.Name, data.Value.ID.ToString());
-                }
-            }
-            bot.GetCommandsInterface.SmartCommandReply(true,args[0], "group=" + args[1], CommandName,collection);
-            base.Callback(args, e);
-        }
-    }
-}

Core/Commands/Group/group.cs

@@ -1,58 +0,0 @@
-using OpenMetaverse;
-using System.Collections.Generic;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public abstract class CoreGroupCommand_SmartReply_auto : CoreCommand_SmartReply_1arg
-    {
-        protected virtual string RunFunction()
-        {
-            return "";
-        }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true, args[0], RunFunction(), CommandName, collection);
-            }
-            return bot.GetCommandsInterface.SmartCommandReply(false, args[0], "", CommandName);
-        }
-    }
-
-    public abstract class CoreGroupCommand_SmartReply_Group : CoreCommand_2arg
-    {
-        protected Dictionary<string, string> collection = new Dictionary<string, string>();
-        public override string[] ArgTypes { get { return new[] { "Mixed", "UUID" }; } }
-        public override string[] ArgHints { get { return new[] { "Smart reply [Channel|IM uuid|http url]", "Group" }; } }
-    }
-
-    public abstract class CoreGroupCommand_SmartReply_Group_auto : CoreGroupCommand_SmartReply_Group
-    {
-        protected virtual string RunFunction(UUID group)
-        {
-            return "";
-        }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[1], out UUID targetgroup) == true)
-                {
-                    if (bot.MyGroups.ContainsKey(targetgroup) == true)
-                    {
-                        return bot.GetCommandsInterface.SmartCommandReply(true,args[0], RunFunction(targetgroup), CommandName);
-                    }
-                    else
-                    {
-                        return Failed("Unknown group");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild UUID");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/groupchat.cs

@@ -1,62 +0,0 @@
-using OpenMetaverse;
-using System;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class Groupchat : CoreCommand_2arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID","TEXT" }; } }
-        public override string[] ArgHints { get { return new[] { "Group","Message" }; } }
-        public override string Helpfile { get { return "Sends a message [ARG 2] to the group [ARG 1]"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID targetgroup) == true)
-                {
-                    if (bot.MyGroups.ContainsKey(targetgroup) == true)
-                    {
-                        if (bot.GetActiveGroupchatSessions.Contains(targetgroup) == true)
-                        {
-                            Callback(args, null);
-                            return true;
-                        }
-                        else
-                        {
-                            if (bot.CreateAwaitEventReply("groupchatjoin", this, args) == true)
-                            {
-                                bot.GetClient.Self.RequestJoinGroupChat(targetgroup);
-                                return true;
-                            }
-                            else
-                            {
-                                return Failed("Unable to await reply");
-                            }
-                        }
-                    }
-                    else
-                    {
-                        return Failed("Unkown group");
-                    }
-                }
-                else
-                {
-                    return Failed("Invaild UUID");
-                }
-            }
-            return false;
-        }
-        public override void Callback(string[] args, EventArgs e)
-        {
-            if (UUID.TryParse(args[0], out UUID targetgroup) == true)
-            {
-                bot.GetClient.Self.InstantMessageGroup(targetgroup, args[1]);
-                base.Callback(args, e);
-            }
-            else
-            {
-                base.Callback(args, e,false);
-            }
-        }
-    }
-}

Core/Commands/Group/groupchatAnyUnread.cs

@@ -1,11 +0,0 @@
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupchatAnyUnread : CoreGroupCommand_SmartReply_auto
-    {
-        public override string Helpfile { get { return "Returns True|False via the smart reply target if there are any unread group ims"; } }
-        protected override string RunFunction()
-        {
-            return "groupchatunread="+bot.HasUnreadGroupchats().ToString();
-        }
-    }
-}

Core/Commands/Group/groupchatClearAll.cs

@@ -1,16 +0,0 @@
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupchatClearAll : CoreCommand
-    {
-        public override string Helpfile { get { return "Clears all group chat buffers at once"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                bot.ClearAllGroupchat();
-                return true;
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Group/groupchatGroupHasUnread.cs

@@ -1,15 +0,0 @@
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupchatGroupHasUnread : CoreGroupCommand_SmartReply_Group_auto
-    {
-        public override string Helpfile { get { return "Returns True|False via the smart reply target if there are any unread group ims for the group [ARG 2]"; } }
-
-        protected override string RunFunction(UUID targetgroup)
-        {
-            return ""+targetgroup.ToString()+"=" + bot.GroupHasUnread(targetgroup).ToString();
-        }
-
-    }
-}

Core/Commands/Group/groupchatHistory.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Linq;
-using Microsoft.VisualBasic.CompilerServices;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Group
-{
-    class GroupchatHistory : CoreGroupCommand_SmartReply_Group_auto
-    {
-        public override string Helpfile { get { return "Returns the chat history for the selected group [ARG 2] via smart reply [ARG 1]"; } }
-        protected override string RunFunction(UUID targetgroup)
-        {
-            int entry = 1;
-            foreach(string A in bot.GetGroupchat(targetgroup))
-            {
-                collection.Add(entry.ToString(),A);
-                entry++;
-            }
-            return "group="+targetgroup.ToString()+"";
-        }
-    }
-}

Core/Commands/Group/groupchatListAllUnreadGroups.cs

@@ -1,21 +0,0 @@
-using OpenMetaverse;
-using System.Text;
-
-namespace BetterSecondBot.Commands.Group
-{
-    public class GroupchatListAllUnreadGroups : CoreGroupCommand_SmartReply_auto
-    {
-        public override string Helpfile { get { return "Returns what groups have unread messages "; } }
-
-        protected override string RunFunction()
-        {
-            int entry = 1;
-            foreach (UUID group in bot.UnreadGroupchatGroups())
-            {
-                collection.Add(entry.ToString(),group.ToString());
-                entry++;
-            }
-            return "count="+collection.Count.ToString();
-        }
-    }
-}

Core/Commands/Home/GoHome.cs

@@ -1,16 +0,0 @@
-namespace BetterSecondBot.Commands.Home
-{
-    public class GoHome : CoreCommand
-    {
-        public override string Helpfile { get { return "Makes the bot teleport to its home region"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                bot.GotoNextHomeRegion();
-                return true;
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Home/resetAtHome.cs

@@ -1,16 +0,0 @@
-namespace BetterSecondBot.Commands.Home
-{
-    public class ResetAtHome : CoreCommand
-    {
-        public override string Helpfile { get { return "Resets the at home lockouts"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if(base.CallFunction(args) == true)
-            {
-                bot.ResetAtHome();
-                return true;
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Info/Balance.cs

@@ -1,21 +0,0 @@
-namespace BetterSecondBot.Commands.Info
-{
-    public class Balance : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Requests the current balance and sends that via the smart reply target and then requests the balance to update."; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetAllowFunds == true)
-                {
-                    bool status = bot.GetCommandsInterface.SmartCommandReply(true,args[0], bot.GetClient.Self.Balance.ToString(), CommandName);
-                    bot.GetClient.Self.RequestBalance();
-                    return status;
-                }
-                return bot.GetCommandsInterface.SmartCommandReply(false,args[0], "0", CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Info/GetPosition.cs

@@ -1,15 +0,0 @@
-namespace BetterSecondBot.Commands.Info
-{
-    public class GetPosition : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Requests the Position and sends that via the smart reply target"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true,args[0], bot.GetClient.Self.RelativePosition.ToString(), CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Info/ParcelName.cs

@@ -1,16 +0,0 @@
-namespace BetterSecondBot.Commands.Info
-{
-    public class ParcelName : ParcelCommand_CheckParcel_1arg_smart
-    {
-        public override string Helpfile { get { return "Fetchs the current parcels name and sends it to the smart reply target on [ARG 1]"; } }
-
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true,args[0], targetparcel.Name, CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Info/SimName.cs

@@ -1,15 +0,0 @@
-namespace BetterSecondBot.Commands.Info
-{
-    public class SimName : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Requests the current Sim Position and sends that via the smart reply target"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true,args[0], bot.GetClient.Network.CurrentSim.Name, CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Info/UnixTimeNow.cs

@@ -1,17 +0,0 @@
-using BetterSecondBotShared.Static;
-
-namespace BetterSecondBot.Commands.Info
-{
-    public class UnixTimeNow : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Requests the current unixtime at the bot and sends that via the smart reply target"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true,args[0], helpers.UnixTimeNow().ToString(), CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/CickObject.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-
-
-namespace BetterSecondBot.Commands.Self
-{
-    public class ClickObject : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID" }; } }
-        public override string[] ArgHints { get { return new[] { "Object UUID" }; } }
-        public override string Helpfile { get { return "Makes the bot attempt to click a object"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if(UUID.TryParse(args[0],out UUID ObjectUUID) == true)
-                {
-                    Dictionary<uint, Primitive> objectsentrys = bot.GetClient.Network.CurrentSim.ObjectsPrimitives.Copy();
-                    bool found_object = false;
-                    foreach (KeyValuePair<uint,Primitive> entry in objectsentrys)
-                    {
-                        if(entry.Value.ID == ObjectUUID)
-                        {
-                            bot.GetClient.Objects.ClickObject(bot.GetClient.Network.CurrentSim, entry.Key);
-                            found_object = true;
-                            break;
-                        }
-                    }
-                    if(found_object == true)
-                    {
-                        return true;
-                    }
-                    else
-                    {
-                        return Failed("Unable to see object");
-                    }
-                }
-                else
-                {
-                    return Failed("UUID not vaild");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/Help.cs

@@ -1,74 +0,0 @@
-using System.Text;
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Self
-{
-    public class Help : CoreCommand
-    {
-
-        public override string Helpfile { get { return "Basic list of commands"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (bot.getMaster_uuid != UUID.Zero)
-            {
-              
-                StringBuilder sb = new StringBuilder();
-                sb.Append("Second Bot - Basic Command List\n\n");
-                sb.Append(bot.GetCommandsInterface.GetCommandHelp("im"));
-                sb.Append("\n\n");
-                sb.Append(bot.GetCommandsInterface.GetCommandHelp("say"));
-                sb.Append("\n\n");
-                sb.Append(bot.GetCommandsInterface.GetCommandHelp("botsit"));
-                sb.Append("\n\n");
-                sb.Append("\nType: 'morehelp' for a full list of commands\n");
-                sb.Replace("<br/>", "\n");
-                bot.SendIM(bot.getMaster_uuid, sb.ToString());
-
-                return true;
-            }
-            else
-            {
-                return Failed("UUID is not vaild");
-            }
-        }
-    }
-    public class MoreHelp : CoreCommand
-    {
-     
-        public override string Helpfile { get { return "Generates a notecard of all supported commands"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (bot.getMaster_uuid != UUID.Zero)
-            {
-
-
-                StringBuilder reply = new StringBuilder();
-                reply.Append("Second Bot - Full Command List\n\n");
-                foreach (string a in bot.GetCommandsInterface.GetCommandsList())
-                {
-                    reply.Append(a);
-                    reply.Append("\n");
-                    reply.Append(bot.GetCommandsInterface.GetCommandHelp(a));
-                    reply.Append("\n\n");
-                }
-                reply.Replace("<br/>", "\n");
-                reply.Replace("</table>", "");
-                reply.Replace("</td><td>", "\n");
-                reply.Replace("</tr><tr>", "\n");
-                reply.Replace("</td>", "");
-                reply.Replace("<td>", "");
-                reply.Replace("</tr>", "");
-                reply.Replace("<table border='1'><tr>", "");
-                reply.Replace("<hr/>", " ");
-               
-                bot.SendNotecard("SecondBot - All Commands", reply.ToString(), bot.getMaster_uuid);
-
-                return true;
-            }
-            else
-            {
-                return Failed("UUID is not vaild");
-            }
-        }
-    }
-}

Core/Commands/Self/PayObject.cs

@@ -1,45 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Linq;
-using OpenMetaverse;
-
-
-namespace BetterSecondBot.Commands.Self
-{
-    public class PayObject : CoreCommand_3arg
-    {
-        public override string[] ArgTypes { get { return new[] { "UUID","Number","Text" }; } }
-        public override string[] ArgHints { get { return new[] { "Object UUID","Amount to pay","Object Name" }; } }
-        public override string Helpfile { get { return "Makes the bot pay a object"; } }
-        public override bool CallFunction(string[] args)
-        {
-
-            if (base.CallFunction(args) == true)
-            {
-                if (bot.GetAllowFunds == true)
-                {
-                    if (UUID.TryParse(args[0], out UUID objectuuid) == true)
-                    {
-                        if (int.TryParse(args[1], out int amount) == true)
-                        {
-                            if (amount > 0)
-                            {
-                                if (args[2].Length > 0)
-                                {
-                                    bot.GetClient.Self.GiveObjectMoney(objectuuid, amount, args[2]);
-                                    return true;
-                                }
-                                return Failed("Invaild object name");
-                            }
-                        }
-                        return Failed("Invaild amount");
-                    }
-                    return Failed("Invaild object UUID");
-                }
-                return Failed("Transfer funds to objects disabled");
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/botVersion.cs

@@ -1,15 +0,0 @@
-namespace BetterSecondBot.Commands.Self
-{
-    class BotVersion : CoreCommand_SmartReply_1arg
-    {
-        public override string Helpfile { get { return "Returns the bots build version"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                return bot.GetCommandsInterface.SmartCommandReply(true,args[0], bot.MyVersion, CommandName);
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/logout.cs

@@ -27,8 +27,7 @@ namespace BetterSecondBot.Commands.Self
         public override string Helpfile { get { return "Makes the bot kill itself you monster"; } }
         public override bool CallFunction(string[] args)
         {
-            bot.GetClient.Self.Chat("Laters im out", 0, ChatType.Normal);
+
-            bot.KillMePlease();
             return true;
         }
     }

Core/Commands/Self/pointAt.cs

@@ -1,40 +0,0 @@
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Self
-{ 
-    public class PointAt : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Avatar" }; } }
-        public override string[] ArgHints { get { return new[] { "Avatar [UUID or Firstname Lastname]" }; } }
-        public override string Helpfile { get { return "Makes the bot turn to face [ARG 1] and point at them (if found)"; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                if (UUID.TryParse(args[0], out UUID testavatar) == true)
-                {
-                    if (bot.GetClient.Network.CurrentSim.AvatarPositions.ContainsKey(testavatar) == true)
-                    {
-                        bot.ResetAnimations();
-                        bot.GetClient.Self.Stand();
-                        bot.GetClient.Self.Movement.TurnToward(bot.GetClient.Network.CurrentSim.AvatarPositions[testavatar]);
-                        bot.GetClient.Self.Movement.SendUpdate();
-                        bot.GetClient.Self.AnimationStart(Animations.POINT_YOU, true);
-                        bot.GetClient.Self.PointAtEffect(bot.GetClient.Self.AgentID, testavatar, new Vector3d(0, 0, 0), PointAtType.Select, UUID.Random());
-                        bot.GetClient.Self.BeamEffect(bot.GetClient.Self.AgentID, testavatar, new Vector3d(0, 0, 2), new Color4(255, 255, 255, 1), (float)3.0, UUID.Random());
-                        return true;
-                    }
-                    else
-                    {
-                        return Failed("Cant find UUID in sim");
-                    }
-                }
-                else
-                {
-                    return Failed("UUID is not vaild");
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/sit.cs

@@ -1,37 +0,0 @@
-using OpenMetaverse;
-
-namespace BetterSecondBot.Commands.Self
-{
-    public class BotSit : CoreCommand_1arg
-    {
-        public override string[] ArgTypes { get { return new[] { "Mixed" }; } }
-        public override string[] ArgHints { get { return new[] { "Text \"ground\" or a object UUID" }; } }
-        public override string Helpfile { get { return "Makes the bot sit on the ground or on a object if it can see it<br/>Example: BOTSIT|||" + UUID.Zero; } }
-        public override bool CallFunction(string[] args)
-        {
-            if (base.CallFunction(args) == true)
-            {
-                bot.ResetAnimations();
-                bot.GetClient.Self.Stand();
-                if (args[0] == "ground")
-                {
-                    bot.GetClient.Self.SitOnGround();
-                    return true;
-                }
-                else
-                {
-                    if (UUID.TryParse(args[0], out UUID arg_is_uuid) == true)
-                    {
-                        bot.GetClient.Self.RequestSit(arg_is_uuid, Vector3.Zero);
-                        return true;
-                    }
-                    else
-                    {
-                        return Failed("UUID is not vaild");
-                    }
-                }
-            }
-            return false;
-        }
-    }
-}

Core/Commands/Self/stand.cs

@@ -1,13 +0,0 @@
-namespace BetterSecondBot.Commands.Self
-{
-    public class Stand : CoreCommand
-    {
-        public override string Helpfile { get { return "Makes the bot stand up if sitting (also resets animations)"; } }
-        public override bool CallFunction(string[] args)
-        {
-            bot.GetClient.Self.Stand();
-            bot.ResetAnimations();
-            return true;
-        }
-    }
-}

Core/bottypes/EventsBot.cs

@@ -250,6 +250,15 @@ namespace BetterSecondBot.bottypes
 
         }
 
+        public List<UUID> GetGroupMembers(UUID group)
+        {
+            if (group_members_storage.ContainsKey(group) == false)
+            {
+                return null;
+            }
+            return group_members_storage[group].Value;
+        }
+
         public bool FastCheckInGroup(UUID group,UUID avatar)
         {
             if(NeedReloadGroupData(group) == false)