public async Task <TaskResult <ulong> > PostMessage(PlanetMessage msg)
{
//ClientMessage msg = JsonConvert.DeserializeObject<ClientMessage>(json);
if (msg == null)
{
return(new TaskResult <ulong>(false, "Malformed message.", 0));
}
ulong channel_id = msg.ChannelId;
PlanetChatChannel channel = await Context.PlanetChatChannels.FindAsync(channel_id);
// Get index for message
ulong index = channel.Message_Count;
// Update message count. May have to queue this in the future to prevent concurrency issues.
channel.Message_Count += 1;
await Context.SaveChangesAsync();
msg.Index = index;
string json = JsonConvert.SerializeObject(msg);
await MessageHub.Current.Clients.Group(channel_id.ToString()).SendAsync("Relay", json);
return(new TaskResult <ulong>(true, $"Posted message {msg.Index}.", index));
}
public async Task <TaskResult> PostMessage(PlanetMessage msg, 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 != msg.Author_Id)
{
return(new TaskResult(false, "Failed to authorize user."));
}
//ClientMessage msg = JsonConvert.DeserializeObject<ClientMessage>(json);
if (msg == null)
{
return(new TaskResult(false, "Malformed message."));
}
// Stop people from sending insanely large messages
if (msg.Content.Length > 2048)
{
return(new TaskResult(false, "Message is longer than 2048 chars."));
}
// Media proxy layer
msg.Content = await MSPManager.HandleUrls(msg.Content);
PlanetMessageWorker.AddToQueue(msg);
return(new TaskResult(true, "Added message to post queue."));
}
public static async Task OnRelay(string data)
{
PlanetMessage message = JsonConvert.DeserializeObject <PlanetMessage>(data);
CommandContext ctx = new CommandContext();
await ctx.Set(message);
await EventService.OnMessage(ctx);
// check to see if message has a command in it
if (message.Content.Substring(0, 1) == BotPrefix)
{
// get clean command string
string commandstring = message.Content.Replace(BotPrefix, "");
// get args
List <string> args = commandstring.Split(" ").ToList();
args.RemoveAt(0);
// get command
string commandname = message.Content.Split(" ")[0].Replace(BotPrefix, "").ToLower();
CommandInfo command = CommandService.RunCommandString(commandname, args, ctx);
if (command != null)
{
command.Method.Invoke(command.moduleInfo.Instance, command.ConvertStringArgs(args, ctx).ToArray());
}
}
}
public async Task Set(PlanetMessage msg)
{
Planet = await Cache.GetPlanet(msg.Planet_Id);
Channel = await Cache.GetPlanetChannel(msg.Channel_Id, msg.Planet_Id);
Member = await msg.GetAuthorAsync();
Message = msg;
}
public async Task Kill(PlanetMessage ctx)
{
User user = await ctx.GetAuthorUserAsync();
if (user.Id != 735182334984219)
{
return;
}
await ctx.ReplyAsync("Goodbye world...");
Environment.Exit(666);
}
public IEnumerable <PlanetMessage> GetMessages(ulong channel_id)
{
ulong channelId = 1;
PlanetMessage welcome = new PlanetMessage()
{
ChannelId = channelId,
Content = "Welcome back.",
TimeSent = DateTime.UtcNow
};
messageCache.Add(welcome);
return(messageCache.TakeLast(10).ToList());
}
public static async Task PostMessage(ulong channelid, ulong planetid, string msg)
{
PlanetMessage message = new PlanetMessage()
{
Channel_Id = channelid,
Content = msg,
TimeSent = DateTime.UtcNow,
Author_Id = BotId,
Planet_Id = planetid
};
string json = Newtonsoft.Json.JsonConvert.SerializeObject(message);
HttpResponseMessage httpresponse = await httpClient.PostAsJsonAsync <PlanetMessage>($"https://valour.gg/Channel/PostMessage?token={Token}", message);
}
private static async Task MessageHandler(PlanetMessage ctx)
{
var sender = await ctx.GetAuthorUserAsync();
if (sender.Bot && Self == sender)
{
return;
}
await using CocaBotContext db = new();
string id = await ValourToSVID(sender.Id, db);
if (id is null)
{
return;
}
HttpClient httpClient = new();
await httpClient.GetAsync($"https://ubi.vtech.cf/new_valour_message?svid={id}&valour_id={sender.Id}&key={UBIKey}");
}
public async Task Confirm(PlanetMessage ctx)
{
await using CocaBotContext db = new();
var sender = await ctx.GetAuthorUserAsync();
var user = db.Users.Where(x => x.ValourName == sender.Name).SingleOrDefault();
if (user is null)
{
await ctx.ReplyAsync($"Could not find account! Have you done `;valour disconnect {sender.Name}`?");
return;
}
user.Valour = sender.Id;
user.ValourName = null;
await db.SaveChangesAsync();
await ctx.ReplyAsync("Linked Account!");
}
public static async Task PostMessage(ulong channelid, ulong planetid, string msg)
{
PlanetMessage message = new PlanetMessage()
{
Channel_Id = channelid,
Content = msg,
TimeSent = DateTime.UtcNow,
Author_Id = ulong.Parse(Client.Config.BotId),
Planet_Id = planetid
};
string json = Newtonsoft.Json.JsonConvert.SerializeObject(message);
Console.WriteLine("SEND: \n" + json);
HttpResponseMessage httpresponse = await client.PostAsJsonAsync <PlanetMessage>($"https://valour.gg/Channel/PostMessage?token={Client.Config.AuthKey}", message);
TaskResult response = Newtonsoft.Json.JsonConvert.DeserializeObject <TaskResult>(await httpresponse.Content.ReadAsStringAsync());
Console.WriteLine("Sending Message!");
Console.WriteLine(response.ToString());
}
public async Task Uptime(PlanetMessage ctx)
{
TimeSpan time = DateTime.Now - Process.GetCurrentProcess().StartTime;
await ctx.ReplyAsync("Uptime: " + time.Humanize(2));
}
public override async Task <bool> ExecuteCheckAsync(PlanetMessage ctx)
{
await ctx.ReplyAsync("this is another attribute!");
return(false);
}
public async Task Summon(PlanetMessage ctx)
=> await ctx.ReplyAsync("Hello!");
public async Task Sheep(PlanetMessage ctx)
=> await ctx.ReplyAsync("beeee!");
public async Task Website(PlanetMessage ctx)
=> await ctx.ReplyAsync("https://cocabot.cf");
public async Task Privacy(PlanetMessage ctx) => await ctx.ReplyAsync(PrivacyMessage).ConfigureAwait(false);
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);
}
/// <summary>
/// Returns true if the client message matches this server message
/// </summary>
public bool EqualsMessage(PlanetMessage message)
{
return(Hash == message.GetHash());
}
public static void AddToQueue(PlanetMessage message)
{
MessageQueue.Add(message);
}
/// <summary>
/// Returns client version using shared implementation
/// </summary>
public static ClientPlanetMessage FromBase(PlanetMessage message, IMapper mapper)
{
return(mapper.Map <ClientPlanetMessage>(message));
}
public async Task Code(PlanetMessage ctx) => await ctx.ReplyAsync(CodeMessage).ConfigureAwait(false);
