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);
}
