public static async Task RestoreTempbanRoles(ulong id)
{
var user = await Global.GetSwissbotUser(id);
if (user == null)
{
return;
}
var tmban = TempBans.FirstOrDefault(x => x.UserId == id);
if (tmban == null)
{
return;
}
await SwissbotWorkerHandler.AssignTasks(WorkerTask.AddRoles, "add", tmban.PreviousRoles, user.Id);
WorkerTaskCreator.CreateTask(WorkerTask.RemoveRoles, user.Id, "remove", 783462878976016385);
WorkerTaskCreator.CreateTask(WorkerTask.RemoveRoles, user.Id, "remove", 627683033151176744);
}
public static async Task <ulong[]> ClearAndAddTempbanRoles(ulong id)
{
var user = await Global.GetSwissbotUser(id);
if (user == null)
{
return(null);
}
ulong[] roles = null;
RoleRevokes.Add(id, false);
while (RoleRevokes.Any(x => x.Key == id && !x.Value))
{
user = await Global.GetSwissbotUser(id);
roles = user.RoleIds.Where(x => x != Global.SwissGuildId && x != 627683033151176744 && x != 783462878976016385).ToArray();
await SwissbotWorkerHandler.AssignTasks(WorkerTask.RemoveRoles, "remove", roles.Select(x => x).ToArray(), user.Id);
if (!user.RoleIds.Any(x => x == 783462878976016385))
{
WorkerTaskCreator.CreateTask(WorkerTask.AddRoles, user.Id, "add", 783462878976016385);
}
if (!user.RoleIds.Any(x => x == 627683033151176744))
{
WorkerTaskCreator.CreateTask(WorkerTask.AddRoles, user.Id, "add", 627683033151176744);
}
await Task.Delay(1000);
}
RoleRevokes.Remove(id);
return(roles);
}
private static async void HandleDequeue()
{
while (_queue.TryDequeue(out var item))
{
CurrentWorker++;
if (CurrentWorker == Global.Workers.Length)
{
CurrentWorker = -1;
}
if (CurrentWorker == -1)
{
var user = await Global.GetSwissbotUser(item.UserId);
if (user == null)
{
continue;
}
switch (item.Task)
{
case WorkerTask.Deafen:
await user.ModifyAsync(x => x.Deaf = item.Value);
break;
case WorkerTask.Mute:
await user.ModifyAsync(x => x.Mute = item.Value);
break;
case WorkerTask.AddRoles:
List <IRole> roles = new List <IRole>();
foreach (var r in item.Roles)
{
roles.Add(user.Guild.GetRole(r));
}
await user.AddRolesAsync(roles);
break;
case WorkerTask.RemoveRoles:
List <IRole> rs = new List <IRole>();
foreach (var r in item.Roles)
{
rs.Add(user.Guild.GetRole(r));
}
await user.RemoveRolesAsync(rs);
break;
}
}
else
{
if (item.Task == WorkerTask.RemoveRoles || item.Task == WorkerTask.AddRoles)
{
await SwissbotWorkerHandler.AssignTask(item.Task, item.Task == WorkerTask.AddRoles? "add" : "remove", item.Roles, CurrentWorker, item.UserId);
}
else
{
await SwissbotWorkerHandler.AssignTask(item.Task, item.Value, CurrentWorker, item.UserId);
}
}
}
}
private static async void WebSocketServer_MessageReceived(object sender, WebSocketReceiveEventArgs e)
{
if (e.result.MessageType == WebSocketMessageType.Close)
{
Global.ConsoleLog($"Got a close, Updating session", ConsoleColor.Cyan, ConsoleColor.Black);
var user = CurrentClients.FirstOrDefault(x => x.Socket.Equals(e.socket));
if (user == null)
{
return;
}
user.SetDisconnected();
return;
}
// Deserialize the data
string content = Encoding.UTF8.GetString(e.data);
IWebsocketMessage message;
try
{
message = JsonConvert.DeserializeObject <WebsocketMessage>(content);
}
catch (Exception x)
{
Global.ConsoleLog("Closing client with bad message type", ConsoleColor.Cyan, ConsoleColor.Black);
// Close the socket
CurrentClients.RemoveAll(x => x.Socket.Equals(e.socket));
await e.socket.CloseAsync(WebSocketCloseStatus.InvalidMessageType, "Bad Handshake", CancellationToken.None);
return;
}
switch (message.type)
{
case "handshake":
Global.ConsoleLog("Got new handshake", ConsoleColor.Cyan, ConsoleColor.Black);
// Parse the handshake
Handshake hs = Handshake.fromContent(content);
if (hs.workerId != -1)
{
if (SwissbotWorkerHandler.isValidHandshake(hs))
{
SwissbotWorkerHandler.AcceptHandshake(hs, e.socket);
await e.socket.SendAsync(Encoding.UTF8.GetBytes("{\"type\": \"handshake_accept\"}"), WebSocketMessageType.Text, true, CancellationToken.None);
return;
}
else
{
// Bad handshake
await e.socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Invalid session", CancellationToken.None);
return;
}
}
else
{
// Check if the user has a valid session
var u = DiscordAuthKeeper.GetUser(hs.session);
if (u == null)
{
Global.ConsoleLog($"No session was provided for new websocket user,\nsession: {hs.session}\npacket: {content}", ConsoleColor.Yellow);
await e.socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Invalid session", CancellationToken.None);
return;
}
// Check if they have permission for the requested events
if (!EventPermissions.hasPermissionForEvent(u, hs.events))
{
Global.ConsoleLog("Invalid permissions for websocket user", ConsoleColor.Yellow);
byte[] returnData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new
{
status = $"Invalid Permissions for the requested event(s): {string.Join(", ", hs.events)}",
type = "handshake_deny"
}));
await e.socket.SendAsync(returnData, WebSocketMessageType.Text, true, CancellationToken.None);
return;
}
// Check if this is a resumed session
if (CanResumeSession(hs))
{
// Resume the session
var session = GetResumedSession(hs);
session.ResumeSession(hs, e.socket);
Global.ConsoleLog($"Resumed {session.User.Username}'s session", ConsoleColor.Cyan, ConsoleColor.Black);
}
else
{
Global.ConsoleLog("Creating new WebsocketUser", ConsoleColor.Cyan, ConsoleColor.Black);
// Add the client
CurrentClients.Add(new WebsocketUser(hs, e.socket));
}
// Send an OK status
byte[] data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new
{
status = "OK",
type = "handshake_accept"
}));
await e.socket.SendAsync(data, WebSocketMessageType.Text, true, CancellationToken.None);
}
break;
case "Log":
WorkerLog log = JsonConvert.DeserializeObject <WorkerLog>(content);
SwissbotWorkerHandler.WorkerLog(log.message);
break;
default:
if (customEvent.ContainsKey(message.type))
{
if (EventPermissions.hasPermissionForEvent(message.session.Replace("csSessionID=", ""), message.type))
{
var task = customEvent[message.type];
await Task.Run(() => task.Invoke(new RawWebsocketMessage(message, content, e.socket)).ConfigureAwait(false));
}
}
break;
}
}
