public async Task <TaskResult> KickUser(ulong id, ulong Planet_Id, ulong userid, string token) { AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new TaskResult(false, "Failed to authorize user.")); } PlanetMember member = await Context.PlanetMembers.Where(x => x.User_Id == id && x.Planet_Id == Planet_Id).FirstOrDefaultAsync(); if (member == null) { return(new TaskResult(true, $"Could not find PlanetMember {id}")); } Context.PlanetMembers.Remove(member); await Context.SaveChangesAsync(); return(new TaskResult(true, $"Successfully kicked user {id}")); }
/// <summary> /// Returns a planet member given the user and planet id /// </summary> public async Task <TaskResult <PlanetMember> > GetPlanetMember(ulong user_id, ulong planet_id, string auth) { // Retrieve planet ServerPlanet planet = ServerPlanet.FromBase(await Context.Planets.FindAsync(planet_id)); if (planet == null) { return(new TaskResult <PlanetMember>(false, "The planet could not be found.", null)); } // Authentication flow AuthToken token = await Context.AuthTokens.FindAsync(auth); // If authorizor is not a member of the planet, they do not have authority to get member info if (token == null || !(await planet.IsMemberAsync(token.User_Id))) { return(new TaskResult <PlanetMember>(false, "Failed to authorize.", null)); } // At this point the request is authorized PlanetMember member = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.User_Id == user_id && x.Planet_Id == planet_id); if (member == null) { return(new TaskResult <PlanetMember>(false, "Could not find member.", null)); } return(new TaskResult <PlanetMember>(true, "Successfully retrieved planet user.", member)); }
public async Task <TaskResult> Join(string code, ulong userid, string token) { AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new TaskResult(false, $"Incorrect token!")); } PlanetInvite invite = await Context.PlanetInvites.FindAsync(code); if (invite == null) { return(new TaskResult(false, $"Code is not found!")); } PlanetBan ban = await Context.PlanetBans.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id); if (ban != null) { return(new TaskResult(false, $"User is banned from this planet!")); } PlanetMember mem = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id); if (mem != null) { return(new TaskResult(false, $"User is already in this planet!")); } Planet planet = await Context.Planets.FirstOrDefaultAsync(x => x.Id == invite.Planet_Id); if (!planet.Public) { return(new TaskResult(false, $"Planet is set to private!")); } PlanetMember member = new PlanetMember() { User_Id = userid, Planet_Id = invite.Planet_Id, }; await Context.PlanetMembers.AddAsync(member); await Context.SaveChangesAsync(); return(new TaskResult(true, $"Joined Planet")); }
public static async Task <PlanetMember> GetPlanetMember(ulong UserId, ulong PlanetId) { PlanetMember member = PlanetMemberCache.Values.FirstOrDefault(x => x.Planet_Id == PlanetId && x.User_Id == UserId); if (member == null) { member = await ValourClient.GetData <PlanetMember>($"https://valour.gg/Planet/GetPlanetMember?user_id={UserId}&planet_id={PlanetId}&auth={ValourClient.Token}"); PlanetMemberCache.TryAdd(member.Id, member); } return(member); }
public static async Task UpdateMembersFromPlanetAsync(ulong PlanetId) { foreach (PlanetMemberInfo memberinfo in await ValourClient.GetData <List <PlanetMemberInfo> >($"https://valour.gg/Planet/GetPlanetMemberInfo?planet_id={PlanetId}&token={ValourClient.Token}")) { if (PlanetMemberCache.ContainsKey(memberinfo.Member.Id) == false) { PlanetMember member = memberinfo.Member; member.RoleIds = new List <ulong>(); member.RoleIds.AddRange(memberinfo.RoleIds); PlanetMemberCache.TryAdd(memberinfo.Member.Id, member); } } }
public async Task Leaderboard(CommandContext ctx) { List <User> users = await Task.Run(() => Client.DBContext.Users.Where(x => x.PlanetId == ctx.Message.Planet_Id).OrderByDescending(x => x.Xp).Take(10).ToList()); string content = "| nickname | xp |\n| :- | :-\n"; foreach (User USER in users) { PlanetMember member = await ctx.Planet.GetMember(USER.UserId, USER.PlanetId); content += $"{member.Nickname} | {(ulong)USER.Xp} xp\n"; } await ctx.ReplyAsync(content); }
public async Task <TaskResult> BanUser(ulong id, ulong Planet_Id, string reason, ulong userid, string token, uint time) { AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new TaskResult(false, "Failed to authorize user.")); } ServerPlanet planet = await ServerPlanet.FindAsync(Planet_Id, Mapper); if (!(await planet.AuthorizedAsync(authToken, PlanetPermissions.Ban))) { return(new TaskResult(false, "You are not authorized to do this.")); } PlanetBan ban = new PlanetBan() { Reason = reason, Planet_Id = Planet_Id, User_Id = id, Banner_Id = userid, Time = DateTime.UtcNow, Permanent = false }; if (time <= 0) { ban.Permanent = true; } else { ban.Minutes = time; } // Add channel to database await Context.PlanetBans.AddAsync(ban); PlanetMember member = await Context.PlanetMembers.Where(x => x.User_Id == id).FirstOrDefaultAsync(); Context.PlanetMembers.Remove(member); await Context.SaveChangesAsync(); return(new TaskResult(true, $"Successfully banned user {id}")); }
public async Task richest(CommandContext ctx) { List <User> DBUsers = await Task.Run(() => Client.DBContext.Users.Where(x => x.PlanetId == ctx.Message.Planet_Id).OrderByDescending(x => x.Coins).Take(10).ToList()); string content = "| nickname | coins |\n| :- | :-\n"; foreach (User user in DBUsers) { PlanetMember clientuser = await user.GetAuthor(); content += $"{clientuser.Nickname} | {(ulong)user.Coins} coins\n"; } await ctx.ReplyAsync(content); }
public async Task <TaskResult <ClientPlanetInvite> > GetInvite(string code, ulong userid) { PlanetInvite invite = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == code); if (invite.IsPermanent() == false) { if (DateTime.UtcNow > invite.Time.AddMinutes((double)invite.Hours)) { Context.PlanetInvites.Remove(invite); await Context.SaveChangesAsync(); return(new TaskResult <ClientPlanetInvite>(false, $"Invite is expired", null)); } } PlanetBan ban = await Context.PlanetBans.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id); if (ban != null) { return(new TaskResult <ClientPlanetInvite>(false, $"User is banned from this planet!", null)); } PlanetMember member = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id); if (member != null) { return(new TaskResult <ClientPlanetInvite>(false, $"User is already in this planet!", null)); } ClientPlanetInvite clientinvite = ClientPlanetInvite.FromBase(invite, Mapper); Planet planet = await Context.Planets.FirstOrDefaultAsync(x => x.Id == invite.Planet_Id); if (!planet.Public) { return(new TaskResult <ClientPlanetInvite>(false, $"Planet is set to private!", null)); } clientinvite.PlanetName = planet.Name; return(new TaskResult <ClientPlanetInvite>(true, $"Successfully got invite", clientinvite)); }
public async Task <LocalRedirectResult> Join(string code, ulong userid, string token) { AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new LocalRedirectResult("/")); } PlanetInvite invite = await Context.PlanetInvites.Where(x => x.Code == code).FirstOrDefaultAsync(); if (invite == null) { return(new LocalRedirectResult("/")); } PlanetMember mem = await Context.PlanetMembers.Where(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id).FirstOrDefaultAsync(); if (mem != null) { return(new LocalRedirectResult("/")); } PlanetMember member = new PlanetMember() { User_Id = userid, Planet_Id = invite.Planet_Id, }; await Context.PlanetMembers.AddAsync(member); await Context.SaveChangesAsync(); return(new LocalRedirectResult("/")); }
public async Task UpdateLotteries(Dictionary <ulong, Lottery> lotterycache, PopeAIDB Context) { foreach (Lottery lottery in Context.Lotteries) { if (DateTime.UtcNow > lottery.EndDate) { lotterycache.Remove(lottery.PlanetId); int total = (int)await Context.LotteryTickets.SumAsync(x => (double)x.Tickets); Random rnd = new Random(); ulong WinningTicketNum = (ulong)rnd.Next(1, total + 1); ulong currentnum = 1; foreach (LotteryTicket ticket in Context.LotteryTickets.Where(x => x.PlanetId == lottery.PlanetId)) { if (currentnum + ticket.Tickets >= WinningTicketNum) { if (lottery.Type == "message") { await Context.AddStat("Coins", lottery.Jackpot, lottery.PlanetId, Context); } User winninguser = await Context.Users.FirstOrDefaultAsync(x => x.PlanetId == lottery.PlanetId && x.UserId == ticket.UserId); winninguser.Coins += lottery.Jackpot; PlanetMember planetuser = await winninguser.GetAuthor(); //await Program.PostMessage(lottery.ChannelId, lottery.PlanetId, $"{planetuser.Nickname} has won the lottery with a jackpot of over {(ulong)lottery.Jackpot} coins!"); Context.LotteryTickets.Remove(ticket); } else { currentnum += ticket.Tickets; } Context.Lotteries.Remove(lottery); } } } await Context.SaveChangesAsync(); }
public async Task UpdateDailyTasks(PopeAIDB Context) { foreach (DailyTask task in Context.DailyTasks) { if (DateTime.UtcNow.Day != task.LastDayUpdated.Day) { Context.DailyTasks.Remove(task); } } await Context.SaveChangesAsync(); foreach (User user in Context.Users) { PlanetMember member = await Cache.GetPlanetMember(user.UserId, user.PlanetId); if (await Context.DailyTasks.FirstOrDefaultAsync(x => x.MemberId == member.Id) == null) { // create 3 new tasks await GenerateNewDailyTasks(Context, member.Id); } } await Context.SaveChangesAsync(); }
/// <summary> /// Creates a server and if successful returns a task result with the created /// planet's id /// </summary> public async Task <TaskResult <ulong> > CreatePlanet(string name, string image_url, ulong userid, string token) { TaskResult nameValid = ValidateName(name); if (!nameValid.Success) { return(new TaskResult <ulong>(false, nameValid.Message, 0)); } if (image_url.Length > 255) { return(new TaskResult <ulong>(false, "Image url must be under 255 characters.", 0)); } AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new TaskResult <ulong>(false, "Failed to authorize user.", 0)); } // User is verified and given planet info is valid by this point // We don't actually need the user object which is cool Planet planet = new Planet() { Name = name, Member_Count = 1, Description = "A Valour server.", Image_Url = image_url, Public = true, Owner_Id = userid }; await Context.Planets.AddAsync(planet); // Have to do this first for auto-incremented ID await Context.SaveChangesAsync(); PlanetMember member = new PlanetMember() { User_Id = userid, Planet_Id = planet.Id }; // Add the owner to the planet as a member await Context.PlanetMembers.AddAsync(member); // Create general channel PlanetChatChannel channel = new PlanetChatChannel() { Name = "General", Planet_Id = planet.Id, Message_Count = 0 }; // Add channel to database await Context.PlanetChatChannels.AddAsync(channel); // Save changes to DB await Context.SaveChangesAsync(); // Return success return(new TaskResult <ulong>(true, "Successfully created planet.", planet.Id)); }
/// <summary> /// Creates a server and if successful returns a task result with the created /// planet's id /// </summary> public async Task <TaskResult <ulong> > CreatePlanet(string name, string image_url, ulong userid, string token) { TaskResult nameValid = ValidateName(name); if (!nameValid.Success) { return(new TaskResult <ulong>(false, nameValid.Message, 0)); } AuthToken authToken = await Context.AuthTokens.FindAsync(token); // Return the same if the token is for the wrong user to prevent someone // from knowing if they cracked another user's token. This is basically // impossible to happen by chance but better safe than sorry in the case that // the literal impossible odds occur, more likely someone gets a stolen token // but is not aware of the owner but I'll shut up now - Spike if (authToken == null || authToken.User_Id != userid) { return(new TaskResult <ulong>(false, "Failed to authorize user.", 0)); } if (await Context.Planets.CountAsync(x => x.Owner_Id == userid) > MAX_OWNED_PLANETS - 1) { return(new TaskResult <ulong>(false, "You have hit your maximum planets!", 0)); } // User is verified and given planet info is valid by this point // We don't actually need the user object which is cool // Use MSP for proxying image MSPResponse proxyResponse = await MSPManager.GetProxy(image_url); if (string.IsNullOrWhiteSpace(proxyResponse.Url) || !proxyResponse.Is_Media) { image_url = "https://valour.gg/image.png"; } else { image_url = proxyResponse.Url; } Planet planet = new Planet() { Name = name, Member_Count = 1, Description = "A Valour server.", Image_Url = image_url, Public = true, Owner_Id = userid }; await Context.Planets.AddAsync(planet); // Have to do this first for auto-incremented ID await Context.SaveChangesAsync(); PlanetMember member = new PlanetMember() { User_Id = userid, Planet_Id = planet.Id }; // Add the owner to the planet as a member await Context.PlanetMembers.AddAsync(member); // Create general channel PlanetChatChannel channel = new PlanetChatChannel() { Name = "General", Planet_Id = planet.Id, Message_Count = 0, Description = "General chat channel" }; // Add channel to database await Context.PlanetChatChannels.AddAsync(channel); // Save changes to DB await Context.SaveChangesAsync(); // Return success return(new TaskResult <ulong>(true, "Successfully created planet.", planet.Id)); }
/// <summary> /// Returns the client version from the base /// </summary> public static ClientPlanetMember FromBase(PlanetMember member) { return(MappingManager.Mapper.Map <ClientPlanetMember>(member)); }
public async Task <PlanetMember> GetAuthor() { PlanetMember planetUser = await Cache.GetPlanetMember(UserId, PlanetId); return(planetUser); }
/// <summary> /// Returns the planet membership of a user /// </summary> /// <param name="token"></param> /// <returns></returns> public async Task <TaskResult <List <Planet> > > GetPlanetMembership(ulong id, string token) { if (token == null) { return(new TaskResult <List <Planet> >(false, "Please supply an authentication token", null)); } AuthToken authToken = await Context.AuthTokens.FindAsync(token); if (authToken.User_Id != id) { return(new TaskResult <List <Planet> >(false, $"Could not authenticate for user {id}", null)); } if (!Permission.HasPermission(authToken.Scope, UserPermissions.Membership)) { return(new TaskResult <List <Planet> >(false, $"The given token does not have membership scope", null)); } List <Planet> membership = new List <Planet>(); // Remove this after pre-pre-alpha if (!(await Context.PlanetMembers.AnyAsync(x => x.Planet_Id == 7 && x.User_Id == id))) { PlanetMember newMember = new PlanetMember() { Planet_Id = 7, User_Id = id }; await Context.PlanetMembers.AddAsync(newMember); await Context.SaveChangesAsync(); } List <PlanetBan> bans = await Task.Run(() => Context.PlanetBans.Where(x => x.User_Id == id).ToList()); foreach (PlanetBan ban in bans) { if (ban.Permanent == false) { if (DateTime.UtcNow > ban.Time.AddMinutes((double)ban.Minutes)) { PlanetMember newMember = new PlanetMember() { Planet_Id = ban.Planet_Id, User_Id = ban.User_Id }; await Context.PlanetMembers.AddAsync(newMember); Context.PlanetBans.Remove(ban); await Context.SaveChangesAsync(); } } } foreach (PlanetMember member in Context.PlanetMembers.Where(x => x.User_Id == id)) { Planet planet = await Context.Planets.FindAsync(member.Planet_Id); if (await member.IsBanned(Context, planet.Id)) { Context.PlanetMembers.Remove(member); await Context.SaveChangesAsync(); } if (planet != null) { membership.Add(planet); } } return(new TaskResult <List <Planet> >(true, $"Retrieved {membership.Count} planets", membership)); }
static async Task OnMessageRecieve(PlanetMessage message) { string dictkey = $"{message.Author_Id}-{message.Planet_Id}"; PlanetMember ClientUser = null; ClientUser = await message.GetAuthorAsync(); if (MessagesThisMinute.ContainsKey(ClientUser.Id)) { MessagesThisMinute[ClientUser.Id] += 1; } else { MessagesThisMinute.Add(ClientUser.Id, 1); } if (message.Author_Id == ulong.Parse(Client.Config.BotId)) { return; } User user = await Context.Users.FirstOrDefaultAsync(x => x.UserId == message.Author_Id && x.PlanetId == message.Planet_Id); if (lotterycache.ContainsKey(message.Planet_Id)) { if (lotterycache[message.Planet_Id].Type == "message") { Lottery lottery = await Context.Lotteries.FirstOrDefaultAsync(x => x.PlanetId == message.Planet_Id); lottery.Jackpot += lottery.JackpotIncreasePerMesage; await lottery.AddTickets(message.Author_Id, 1, message.Planet_Id, Context); } } if (message.Content.Substring(0, 1) == Client.Config.CommandSign) { string command = message.Content.Split(" ")[0]; command = command.Replace("\n", ""); List <string> ops = message.Content.Split(" ").ToList(); command = command.Replace(Client.Config.CommandSign, ""); if (command == "roll") { if (ops.Count < 3) { await PostMessage(message.Channel_Id, message.Planet_Id, "Command Format: /roll <from> <to>"); return; } int from = int.Parse(ops[1]); int to = int.Parse(ops[2]); int num = rnd.Next(from, to); await PostMessage(message.Channel_Id, message.Planet_Id, $"Roll: {num}"); } if (command == "eco") { if (ops.Count == 1) { ops.Add(""); } switch (ops[1]) { case "cap": int total = 0; foreach (User USER in Context.Users) { total += (int)USER.Coins; } await PostMessage(message.Channel_Id, message.Planet_Id, $"Eco cap: {total} coins"); break; default: await PostMessage(message.Channel_Id, message.Planet_Id, "Available Commands: /eco cap"); break; } } if (command == "forcerolepayout") { if (await ClientUser.IsOwner() != true) { await PostMessage(message.Channel_Id, message.Planet_Id, $"Only the owner of this server can use this command!"); return; } await Context.UpdateRoleIncomes(planets, true, Context); await PostMessage(message.Channel_Id, message.Planet_Id, "Successfully forced a role payout."); } if (command == "lottery") { if (ops.Count() == 1) { ops.Add(""); } switch (ops[1]) { case "timeleft": Lottery lottery = await Context.Lotteries.FirstOrDefaultAsync(x => x.PlanetId == message.Planet_Id); if (lottery == null) { await PostMessage(message.Channel_Id, message.Planet_Id, $"There is no lottery currently going on!"); break; } TimeSpan timeleft = lottery.EndDate.Subtract(DateTime.UtcNow); await PostMessage(message.Channel_Id, message.Planet_Id, $"{timeleft.Hours} hours left"); break; case "tickets": LotteryTicket ticket = await Context.LotteryTickets.FirstOrDefaultAsync(x => x.PlanetId == message.Planet_Id && x.UserId == message.Author_Id); if (ticket == null) { await PostMessage(message.Channel_Id, message.Planet_Id, $"There is no lottery currently going on!"); break; } await PostMessage(message.Channel_Id, message.Planet_Id, $"You have {ticket.Tickets} tickets"); break; case "jackpot": lottery = await Context.Lotteries.FirstOrDefaultAsync(x => x.PlanetId == message.Planet_Id); if (lottery == null) { await PostMessage(message.Channel_Id, message.Planet_Id, $"There is no lottery currently going on!"); break; } await PostMessage(message.Channel_Id, message.Planet_Id, $"The current jackpot is {lottery.Jackpot}"); break; case "create": if (await ClientUser.IsOwner() != true) { await PostMessage(message.Channel_Id, message.Planet_Id, $"Only the owner of this server can use this command!"); break; } if (ops.Count() < 4) { await PostMessage(message.Channel_Id, message.Planet_Id, "Command Format: /lottery create coin <hours> or /lottery create message <how many coins will each message add> <hours>"); break; } string type = ops[2]; int HoursToLast = 0; if (type == "message") { if (ops.Count() < 5) { await PostMessage(message.Channel_Id, message.Planet_Id, "Command Format: /lottery create message <how many coins will each message add> <hours>"); break; } HoursToLast = int.Parse(ops[4]); } else { HoursToLast = int.Parse(ops[3]); } if (HoursToLast > 24) { await PostMessage(message.Channel_Id, message.Planet_Id, "You can not have a lottery last more than 24 hours!"); break; } if (type != "coin" && type != "message") { await PostMessage(message.Channel_Id, message.Planet_Id, "Type must either by coin or message!"); break; } // check if the planet is areadly doing a lottery lottery = await Context.Lotteries.FirstOrDefaultAsync(x => x.PlanetId == message.Planet_Id); if (lottery != null) { await PostMessage(message.Channel_Id, message.Planet_Id, "You can not have two lotteries running at the same time!"); break; } lottery = new Lottery(); lottery.StartDate = DateTime.UtcNow; lottery.Type = type; lottery.PlanetId = message.Planet_Id; lottery.EndDate = DateTime.UtcNow.AddHours(HoursToLast); lottery.Jackpot = 0; lottery.ChannelId = message.Channel_Id; if (type == "message") { lottery.JackpotIncreasePerMesage = (double)int.Parse(ops[3]); } else { lottery.JackpotIncreasePerMesage = 0; } await Context.Lotteries.AddAsync(lottery); lotterycache.Add(lottery.PlanetId, lottery); await PostMessage(message.Channel_Id, message.Planet_Id, "Successfully created a lottery."); await Context.SaveChangesAsync(); break; default: await PostMessage(message.Channel_Id, message.Planet_Id, "Command Format: /lottery create coin <hours> or /lottery create message <how many coins will each message add> <hours>"); break; } } } Console.WriteLine(message.Content); }