public async Task <DiscordGuildMemberPacket> GetGuildUserAsync(ulong userId, ulong guildId)
{
string key = $"discord:guild:{guildId}:user:{userId}";
DiscordGuildMemberPacket packet = null;
if (await cache.ExistsAsync(key))
{
packet = await cache.GetAsync <DiscordGuildMemberPacket>(key);
}
else
{
var rc = await RatelimitHelper.ProcessRateLimitedAsync(
$"guilds:{guildId}", cache,
async() =>
{
return(await RestClient.GetAsync <DiscordGuildMemberPacket>($"/guilds/{guildId}/members/{userId}"));
});
packet = rc.Data;
await cache.AddAsync(key, rc.Data);
}
packet.User = await GetUserAsync(userId);
packet.GuildId = guildId;
packet.UserId = userId;
return(packet);
}
private async Task OnGuildMemberAdd(DiscordGuildMemberPacket arg)
{
try
{
DiscordGuildPacket guild = await _discordClient.GetGuildAsync(arg.GuildId);
if (guild.Members == null)
{
guild.Members = new List <DiscordGuildMemberPacket>();
}
int index = guild.Members.FindIndex(x => x.UserId == arg.UserId);
if (index != -1)
{
guild.Members.RemoveAt(index);
}
guild.Members.Add(
await _discordClient.GetGuildUserAsync(arg.UserId, arg.GuildId)
);
var cache = _cacheClient.Get;
await cache.UpsertAsync($"discord:guild:{arg.GuildId}:user:{arg.UserId}", arg);
await cache.UpsertAsync($"discord:guild:{arg.GuildId}", guild);
}
catch (Exception e)
{
Log.Trace(e.ToString());
}
}
public async ValueTask OnGuildMemberAdd(DiscordGuildMemberPacket packet)
{
await InsertGuildMemberCacheAsync(packet);
var member = new DiscordGuildUser(packet, Client);
await EventHandler.OnGuildMemberCreate(member);
}
public DiscordGuildUserName(DiscordGuildMemberPacket packet)
{
Id = packet.User.Id;
Username = packet.User.Username;
NormalizedUsername = StringHelper.Normalize(packet.User.Username);
Nickname = packet.Nickname;
NormalizedNickname = StringHelper.Normalize(packet.Nickname);
Discriminator = packet.User.Discriminator;
}
private async Task OnGuildMemberUpdate(GuildMemberUpdateEventArgs arg)
{
try
{
DiscordGuildPacket guild = await _discordClient.GetGuildAsync(arg.GuildId);
if (guild.Members == null)
{
guild.Members = new List <DiscordGuildMemberPacket>();
}
int index = guild.Members.FindIndex(x => x.UserId == arg.User.Id);
DiscordGuildMemberPacket packet;
if (index == -1)
{
packet = new DiscordGuildMemberPacket
{
User = arg.User,
Roles = arg.RoleIds.ToList(),
Nickname = arg.Nickname,
UserId = arg.User.Id,
GuildId = arg.GuildId,
};
guild.Members.Add(packet);
}
else
{
guild.Members[index].Nickname = arg.Nickname;
guild.Members[index].Roles = arg.RoleIds.ToList();
guild.Members[index].User = arg.User;
packet = guild.Members[index];
}
var cache = _cacheClient.Get;
await cache.UpsertAsync($"discord:guild:{arg.GuildId}:user:{arg.User.Id}", packet);
await cache.UpsertAsync($"discord:guild:{arg.GuildId}", guild);
}
catch (Exception e)
{
Log.Trace(e.ToString());
}
}
public async Task <DiscordGuildMemberPacket> GetGuildUserAsync(ulong userId, ulong guildId)
{
string key = $"discord:guild:{guildId}:user:{userId}";
DiscordGuildMemberPacket packet = null;
var cacheClient = cache.Get;
{
if (await cacheClient.ExistsAsync(key))
{
packet = await cacheClient.GetAsync <DiscordGuildMemberPacket>(key);
if (packet == null)
{
Log.Debug($"cache hit on '{key}', but object was invalid");
await cacheClient.RemoveAsync(key);
return(await GetGuildUserAsync(userId, guildId));
}
}
else
{
var rc = await RatelimitHelper.ProcessRateLimitedAsync(
$"guilds:{guildId}", cacheClient,
async() =>
{
return(await RestClient.GetAsync <DiscordGuildMemberPacket>($"/guilds/{guildId}/members/{userId}"));
});
packet = rc.Data;
await cacheClient.UpsertAsync(key, rc.Data);
}
packet.User = await GetUserAsync(userId);
packet.GuildId = guildId;
packet.UserId = userId;
}
return(packet);
}
private async Task OnGuildMemberAdd(DiscordGuildMemberPacket arg)
{
DiscordGuildPacket guild = await _discordClient.GetGuildAsync(arg.GuildId);
if (guild.Members == null)
{
guild.Members = new List <DiscordGuildMemberPacket>();
}
int index = guild.Members.FindIndex(x => x.UserId == arg.UserId);
if (index != -1)
{
guild.Members.RemoveAt(index);
}
guild.Members.Add(
await _discordClient.GetGuildUserAsync(arg.UserId, arg.GuildId)
);
await _cacheClient.AddAsync($"discord:guild:{arg.GuildId}:user:{arg.UserId}", arg);
await _cacheClient.AddAsync($"discord:guild:{arg.GuildId}", guild);
}
private async Task OnMessageAsync(object ch, BasicDeliverEventArgs ea)
{
try
{
var payload = Encoding.UTF8.GetString(ea.Body);
ShardPacket body = JsonConvert.DeserializeObject <ShardPacket>(payload);
Log.Trace("packet with the op-code '" + body.opcode + "' received.");
switch (body.opcode)
{
case Opcode.MessageCreate:
{
if (MessageCreate != null)
{
await MessageCreate(
body.Data.ToObject <DiscordMessagePacket>()
);
}
}
break;
case Opcode.GuildCreate:
{
if (GuildCreate != null)
{
var guild = body.Data.ToObject <DiscordGuildPacket>();
await GuildCreate(
guild
);
}
}
break;
case Opcode.ChannelCreate:
{
if (GuildCreate != null)
{
var channel = body.Data.ToObject <DiscordChannelPacket>();
await ChannelCreate(
channel
);
}
}
break;
case Opcode.GuildMemberRemove:
{
if (GuildMemberRemove != null)
{
var packet = body.Data.ToObject <GuildIdUserArgs>();
await GuildMemberRemove(
packet.guildId,
packet.user
);
}
}
break;
case Opcode.GuildMemberAdd:
{
DiscordGuildMemberPacket guildMember = body.Data.ToObject <DiscordGuildMemberPacket>();
if (GuildMemberAdd != null)
{
await GuildMemberAdd(guildMember);
}
}
break;
case Opcode.GuildMemberUpdate:
{
GuildMemberUpdateEventArgs guildMember = body.Data.ToObject <GuildMemberUpdateEventArgs>();
if (GuildMemberUpdate != null)
{
await GuildMemberUpdate(
guildMember
);
}
}
break;
case Opcode.GuildRoleCreate:
{
RoleEventArgs role = body.Data.ToObject <RoleEventArgs>();
if (GuildRoleCreate != null)
{
await GuildRoleCreate(
role.GuildId,
role.Role
);
}
}
break;
case Opcode.GuildRoleDelete:
{
if (GuildRoleDelete != null)
{
RoleDeleteEventArgs role = body.Data.ToObject <RoleDeleteEventArgs>();
await GuildRoleDelete(
role.GuildId,
role.RoleId
);
}
}
break;
case Opcode.GuildRoleUpdate:
{
RoleEventArgs role = body.Data.ToObject <RoleEventArgs>();
if (GuildRoleUpdate != null)
{
await GuildRoleUpdate(
role.GuildId,
role.Role
);
}
}
break;
case Opcode.ChannelDelete:
{
if (ChannelDelete != null)
{
await ChannelDelete(
body.Data.ToObject <DiscordChannelPacket>()
);
}
}
break;
case Opcode.ChannelUpdate:
{
if (ChannelUpdate != null)
{
await ChannelUpdate(
body.Data.ToObject <DiscordChannelPacket>()
);
}
}
break;
case Opcode.GuildBanAdd:
{
if (GuildBanAdd != null)
{
var packet = body.Data.ToObject <GuildIdUserArgs>();
await GuildBanAdd(
packet.guildId,
packet.user
);
}
}
break;
case Opcode.GuildBanRemove:
{
if (GuildBanRemove != null)
{
var packet = body.Data.ToObject <GuildIdUserArgs>();
await GuildBanRemove(
packet.guildId,
packet.user
);
}
}
break;
case Opcode.GuildDelete:
{
if (GuildDelete != null)
{
var packet = body.Data.ToObject <DiscordGuildUnavailablePacket>();
await GuildDelete(
packet
);
}
}
break;
case Opcode.GuildEmojiUpdate:
{
}
break;
case Opcode.GuildIntegrationsUpdate:
{
}
break;
case Opcode.GuildMembersChunk:
{
}
break;
case Opcode.GuildUpdate:
{
if (GuildUpdate != null)
{
await GuildUpdate(
body.Data.ToObject <DiscordGuildPacket>()
);
}
}
break;
case Opcode.MessageDelete:
{
if (MessageDelete != null)
{
await MessageDelete(
body.Data.ToObject <MessageDeleteArgs>()
);
}
}
break;
case Opcode.MessageDeleteBulk:
{
}
break;
case Opcode.MessageUpdate:
{
if (MessageUpdate != null)
{
await MessageUpdate(
body.Data.ToObject <DiscordMessagePacket>()
);
}
}
break;
case Opcode.PresenceUpdate:
{
}
break;
case Opcode.Ready:
{
}
break;
case Opcode.Resumed:
{
}
break;
case Opcode.TypingStart:
{
}
break;
case Opcode.UserUpdate:
{
if (UserUpdate != null)
{
await UserUpdate(
body.Data.ToObject <DiscordUserPacket>()
);
}
}
break;
case Opcode.VoiceServerUpdate:
{
}
break;
case Opcode.VoiceStateUpdate:
{
}
break;
}
channel.BasicAck(ea.DeliveryTag, false);
}
catch (Exception e)
{
Log.Error(e);
}
}
public DiscordGuildUser(DiscordGuildMemberPacket packet, IDiscordClient client)
: base(packet.User, client)
{
this.packet = packet;
}
public DiscordGuildUser(DiscordGuildMemberPacket packet, DiscordClient client)
{
_packet = packet;
_client = client;
}
private async Task OnGuildMemberAdd(DiscordGuildMemberPacket member)
{
await cacheHandler.Members.AddAsync(member);
}
private static bool ValidateCache(DiscordGuildMemberPacket p) => ValidateCache(p.User);
